Using cached connector directory for discoverable tools list

codex-rs/chatgpt/src/connectors.rs

@@ -4,7 +4,8 @@ use std::time::Duration;
 use crate::chatgpt_client::chatgpt_get_request_with_timeout;
 
 use codex_app_server_protocol::AppInfo;
-use codex_connectors::AllConnectorsCacheKey;
+use codex_connectors::ConnectorDirectoryCacheContext;
+use codex_connectors::ConnectorDirectoryCacheKey;
 use codex_connectors::DirectoryListResponse;
 use codex_connectors::filter::filter_disallowed_connectors;
 use codex_connectors::merge::merge_connectors;
@@ -75,8 +76,8 @@ pub async fn list_cached_all_connectors(config: &Config) -> Option<Vec<AppInfo>>
     }
 
     let auth = connector_auth(config).await.ok()?;
-    let cache_key = all_connectors_cache_key(config, &auth);
-    let connectors = codex_connectors::cached_all_connectors(&cache_key)?;
+    let cache_context = connector_directory_cache_context(config, &auth);
+    let connectors = codex_connectors::cached_directory_connectors(&cache_context)?;
     let connectors = merge_plugin_connectors(
         connectors,
         plugin_apps_for_config(config)
@@ -98,9 +99,9 @@ pub async fn list_all_connectors_with_options(
         return Ok(Vec::new());
     }
     let auth = connector_auth(config).await?;
-    let cache_key = all_connectors_cache_key(config, &auth);
+    let cache_context = connector_directory_cache_context(config, &auth);
     let connectors = codex_connectors::list_all_connectors_with_options(
-        cache_key,
+        cache_context,
         auth.is_workspace_account(),
         force_refetch,
         |path| async move {
@@ -126,12 +127,18 @@ pub async fn list_all_connectors_with_options(
     ))
 }
 
-fn all_connectors_cache_key(config: &Config, auth: &CodexAuth) -> AllConnectorsCacheKey {
-    AllConnectorsCacheKey::new(
-        config.chatgpt_base_url.clone(),
-        auth.get_account_id(),
-        auth.get_chatgpt_user_id(),
-        auth.is_workspace_account(),
+fn connector_directory_cache_context(
+    config: &Config,
+    auth: &CodexAuth,
+) -> ConnectorDirectoryCacheContext {
+    ConnectorDirectoryCacheContext::new(
+        config.codex_home.to_path_buf(),
+        ConnectorDirectoryCacheKey::new(
+            config.chatgpt_base_url.clone(),
+            auth.get_account_id(),
+            auth.get_chatgpt_user_id(),
+            auth.is_workspace_account(),
+        ),
     )
 }
 

codex-rs/connectors/Cargo.toml

@@ -11,8 +11,12 @@ workspace = true
 anyhow = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+sha1 = { workspace = true }
+tracing = { workspace = true }
 urlencoding = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }
+tempfile = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

codex-rs/connectors/src/directory_cache.rs

@@ -0,0 +1,112 @@
+use std::path::PathBuf;
+
+use codex_app_server_protocol::AppInfo;
+use serde::Deserialize;
+use serde::Serialize;
+use sha1::Digest;
+use sha1::Sha1;
+use tracing::warn;
+
+use crate::ConnectorDirectoryCacheKey;
+
+pub(crate) const CONNECTOR_DIRECTORY_DISK_CACHE_SCHEMA_VERSION: u8 = 1;
+const CONNECTOR_DIRECTORY_DISK_CACHE_DIR: &str = "cache/codex_app_directory";
+
+#[derive(Clone)]
+pub struct ConnectorDirectoryCacheContext {
+    pub(crate) codex_home: PathBuf,
+    pub(crate) cache_key: ConnectorDirectoryCacheKey,
+}
+
+impl ConnectorDirectoryCacheContext {
+    pub fn new(codex_home: PathBuf, cache_key: ConnectorDirectoryCacheKey) -> Self {
+        Self {
+            codex_home,
+            cache_key,
+        }
+    }
+
+    pub(crate) fn cache_path(&self) -> PathBuf {
+        let cache_key_json = serde_json::to_string(&self.cache_key).unwrap_or_default();
+        let cache_key_hash = sha1_hex(&cache_key_json);
+        self.codex_home
+            .join(CONNECTOR_DIRECTORY_DISK_CACHE_DIR)
+            .join(format!("{cache_key_hash}.json"))
+    }
+}
+
+pub(crate) enum CachedConnectorDirectoryDiskLoad {
+    Hit { connectors: Vec<AppInfo> },
+    Missing,
+    Invalid,
+}
+
+pub(crate) fn load_cached_directory_connectors_from_disk(
+    cache_context: &ConnectorDirectoryCacheContext,
+) -> CachedConnectorDirectoryDiskLoad {
+    let cache_path = cache_context.cache_path();
+    let bytes = match std::fs::read(&cache_path) {
+        Ok(bytes) => bytes,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+            return CachedConnectorDirectoryDiskLoad::Missing;
+        }
+        Err(err) => {
+            warn!(
+                cache_path = %cache_path.display(),
+                "failed to read connector directory disk cache: {err}"
+            );
+            return CachedConnectorDirectoryDiskLoad::Invalid;
+        }
+    };
+    let cache: ConnectorDirectoryDiskCache = match serde_json::from_slice(&bytes) {
+        Ok(cache) => cache,
+        Err(err) => {
+            warn!(
+                cache_path = %cache_path.display(),
+                "failed to parse connector directory disk cache: {err}"
+            );
+            let _ = std::fs::remove_file(cache_path);
+            return CachedConnectorDirectoryDiskLoad::Invalid;
+        }
+    };
+    if cache.schema_version != CONNECTOR_DIRECTORY_DISK_CACHE_SCHEMA_VERSION {
+        let _ = std::fs::remove_file(cache_path);
+        return CachedConnectorDirectoryDiskLoad::Invalid;
+    }
+
+    CachedConnectorDirectoryDiskLoad::Hit {
+        connectors: cache.connectors,
+    }
+}
+
+pub(crate) fn write_cached_directory_connectors_to_disk(
+    cache_context: &ConnectorDirectoryCacheContext,
+    connectors: &[AppInfo],
+) {
+    let cache_path = cache_context.cache_path();
+    if let Some(parent) = cache_path.parent()
+        && std::fs::create_dir_all(parent).is_err()
+    {
+        return;
+    }
+    let Ok(bytes) = serde_json::to_vec_pretty(&ConnectorDirectoryDiskCache {
+        schema_version: CONNECTOR_DIRECTORY_DISK_CACHE_SCHEMA_VERSION,
+        connectors: connectors.to_vec(),
+    }) else {
+        return;
+    };
+    let _ = std::fs::write(cache_path, bytes);
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ConnectorDirectoryDiskCache {
+    schema_version: u8,
+    connectors: Vec<AppInfo>,
+}
+
+fn sha1_hex(value: &str) -> String {
+    let mut hasher = Sha1::new();
+    hasher.update(value.as_bytes());
+    let sha1 = hasher.finalize();
+    format!("{sha1:x}")
+}