chore: bump codex version

angao · angao · commit 668825273321 · 2026-01-06T20:25:37.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "codex-acp"
 authors = ["angao<gawaine2111@gmail.com>"]
-version = "0.4.1"
+version = "0.4.2"
 edition = "2024"
 description = "ACP-compatible agent that bridges the OpenAI Codex runtime with ACP clients over stdio."
 readme = "README.md"
@@ -12,32 +12,33 @@ rust-version = "1.91"
 agent-client-protocol = { version = "0.9.2", features = ["unstable"] }
 anyhow = { version = "1" }
 async-trait = { version = "0.1" }
+codex-app-server-protocol = { git = "https://github.com/openai/codex", branch = "main" }
 codex-common = { git = "https://github.com/openai/codex", branch = "main", features = [
-    "cli",
+  "cli",
 ] }
 codex-core = { git = "https://github.com/openai/codex", branch = "main" }
 codex-protocol = { git = "https://github.com/openai/codex", branch = "main" }
-codex-app-server-protocol = { git = "https://github.com/openai/codex", branch = "main" }
+codex-utils-absolute-path = { git = "https://github.com/openai/codex", branch = "main" }
+diffy = { version = "0.4.2" }
+rmcp = { version = "0.12.0", features = [
+  "macros",
+  "schemars",
+  "server",
+  "transport-io",
+] }
+schemars = { version = "1", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0.145", features = ["raw_value"] }
 tokio = { version = "1.48.0", features = [
-    "macros",
-    "rt",
-    "io-std",
-    "io-util",
-    "net",
-    "sync",
+  "io-std",
+  "io-util",
+  "macros",
+  "net",
+  "rt",
+  "sync",
 ] }
 tokio-util = { version = "0.7.17", features = ["compat"] }
-serde_json = { version = "1.0.145", features = ["raw_value"] }
-serde = { version = "1.0", features = ["derive"] }
-diffy = { version = "0.4.2" }
 tracing = { version = "0.1", features = ["log"] }
+tracing-appender = { version = "0.2.3" }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uuid = { version = "1", features = ["v4"] }
-rmcp = { version = "0.12.0", features = [
-    "transport-io",
-    "server",
-    "macros",
-    "schemars",
-] }
-schemars = { version = "1", features = ["derive"] }
-tracing-appender = { version = "0.2.3" }
diff --git a/src/agent/commands.rs b/src/agent/commands.rs
@@ -19,6 +19,7 @@ impl CodexAgent {
                     items: vec![UserInput::Text {
                         text: prompt.into(),
                     }],
+                    final_output_json_schema: None,
                 })
             }
             "status" => {
diff --git a/src/agent/config_builder.rs b/src/agent/config_builder.rs
@@ -25,16 +25,13 @@ impl CodexAgent {
         })?;
 
         let mut env = HashMap::new();
-        env.insert(
-            "ACP_FS_BRIDGE_ADDR".to_string(),
-            bridge.address().to_string(),
-        );
-        env.insert("ACP_FS_SESSION_ID".to_string(), session_id.to_string());
+        env.insert("ACP_FS_BRIDGE_ADDR".into(), bridge.address().to_string());
+        env.insert("ACP_FS_SESSION_ID".into(), session_id.to_owned());
 
         Ok(McpServerConfig {
             transport: McpServerTransportConfig::Stdio {
                 command: exe_path.to_string_lossy().into_owned(),
-                args: vec!["--acp-fs-mcp".to_string()],
+                args: vec!["--acp-fs-mcp".into()],
                 env: Some(env),
                 env_vars: vec![],
                 cwd: None,
@@ -47,12 +44,12 @@ impl CodexAgent {
                 let caps = self.session_manager.client_capabilities();
                 let mut v: Vec<String> = Vec::new();
                 if !caps.fs.read_text_file {
-                    v.push("read_text_file".to_string());
+                    v.push("read_text_file".into());
                 }
                 if !caps.fs.write_text_file {
-                    v.push("write_text_file".to_string());
-                    v.push("edit_text_file".to_string());
-                    v.push("multi_edit_text_file".to_string());
+                    v.push("write_text_file".into());
+                    v.push("edit_text_file".into());
+                    v.push("multi_edit_text_file".into());
                 }
                 if v.is_empty() { None } else { Some(v) }
             },
diff --git a/src/agent/events.rs b/src/agent/events.rs
@@ -111,7 +111,7 @@ impl EventHandler {
             )))];
             let mut meta_map = serde_json::Map::new();
             meta_map.insert(
-                "terminal_info".to_string(),
+                "terminal_info".into(),
                 json!({
                     "terminal_id": call_id,
                     "cwd": cwd
@@ -230,7 +230,7 @@ impl EventHandler {
                 }
                 FileChange::Delete { content } => {
                     contents.push(ToolCallContent::from(
-                        Diff::new(PathBuf::from(path), "".to_string()).old_text(content.clone()),
+                        Diff::new(PathBuf::from(path), String::new()).old_text(content.clone()),
                     ));
                 }
                 FileChange::Update { unified_diff, .. } => {
@@ -243,7 +243,7 @@ impl EventHandler {
         }
 
         let title = if changes.len() == 1 {
-            "Apply changes".to_string()
+            String::from("Apply changes")
         } else {
             format!("Edit {} files", changes.len())
         };
diff --git a/src/agent/prompt.rs b/src/agent/prompt.rs
@@ -33,7 +33,7 @@ impl CodexAgent {
     pub(super) async fn prompt(&self, args: PromptRequest) -> Result<PromptResponse, Error> {
         info!(?args, "Received prompt request");
         let event_handler = EventHandler::new(
-            self.config.cwd.clone(),
+            self.config.cwd.clone(), // Required: EventHandler stores PathBuf
             self.session_manager.support_terminal(),
         );
         let mut reason = ReasoningAggregator::new();
@@ -97,7 +97,10 @@ impl CodexAgent {
 
         let op = match op_opt {
             Some(op) => op,
-            None => Op::UserInput { items },
+            None => Op::UserInput {
+                items,
+                final_output_json_schema: None,
+            },
         };
 
         // Enqueue work and then stream corresponding events back as ACP updates.
@@ -148,7 +151,7 @@ impl CodexAgent {
                         && !text.trim().is_empty()
                     {
                         self.session_manager
-                            .send_thought_chunk(&args.session_id, text.clone().into())
+                            .send_thought_chunk(&args.session_id, text.into())
                             .await?;
                     }
                 }
@@ -361,6 +364,7 @@ impl CodexAgent {
                 | EventMsg::StreamError(StreamErrorEvent {
                     message,
                     codex_error_info: _,
+                    additional_details: _,
                 }) => {
                     let mut msg = String::from(&message);
                     msg.push_str("\n\n");
diff --git a/src/agent/session_manager.rs b/src/agent/session_manager.rs
@@ -50,7 +50,7 @@ impl SessionState {
             fs_session_id,
             conversation,
             current_approval: config.approval_policy.value(),
-            current_sandbox: config.sandbox_policy.clone(),
+            current_sandbox: config.sandbox_policy.get().clone(),
             current_mode,
             current_model: Some(format!("{}@{}", provider_id, model_name)),
             current_effort: config.model_reasoning_effort,
diff --git a/src/agent/utils.rs b/src/agent/utils.rs
@@ -109,7 +109,7 @@ pub fn display_fs_path(cwd: &Path, raw_path: &str) -> String {
 
     path.file_name()
         .map(|name| name.to_string_lossy().into_owned())
-        .unwrap_or_else(|| raw_path.to_string())
+        .unwrap_or_else(|| raw_path.to_owned())
 }
 
 /// Extract FS tool metadata from an MCP invocation, when applicable.
@@ -125,7 +125,7 @@ pub fn fs_tool_metadata(invocation: &McpInvocation, cwd: &Path) -> Option<FsTool
     }
 
     let args = invocation.arguments.as_ref()?.as_object()?;
-    let path = args.get("path")?.as_str()?.to_string();
+    let path = args.get("path")?.as_str()?.to_owned();
     let line = args
         .get("line")
         .and_then(|value| value.as_u64())
@@ -176,7 +176,7 @@ pub fn current_mode_id_for_config(config: &Config) -> Option<SessionModeId> {
         .iter()
         .find(|preset| {
             preset.approval == config.approval_policy.value()
-                && preset.sandbox == config.sandbox_policy
+                && preset.sandbox == config.sandbox_policy.get().clone()
         })
         .map(|preset| SessionModeId::new(preset.id))
 }
@@ -197,11 +197,11 @@ pub fn available_modes() -> Vec<SessionMode> {
     APPROVAL_PRESETS
         .iter()
         .map(|preset| {
-            let mode = SessionMode::new(SessionModeId::new(preset.id), preset.label.to_string());
+            let mode = SessionMode::new(SessionModeId::new(preset.id), preset.label);
             if preset.description.is_empty() {
                 mode
             } else {
-                mode.description(preset.description.to_string())
+                mode.description(preset.description)
             }
         })
         .collect()
@@ -263,7 +263,7 @@ pub fn available_models_from_profiles(
             }
 
             candidates.push((
-                provider_id.clone(),
+                provider_id.as_str(),
                 (
                     provider_id.clone(),
                     model_name.clone(),
@@ -274,7 +274,7 @@ pub fn available_models_from_profiles(
     }
 
     // Sort by provider id then model name for stable output.
-    candidates.sort_by(|a, b| a.0.cmp(&b.0).then_with(|| a.1.1.cmp(&b.1.1)));
+    candidates.sort_by(|a, b| a.0.cmp(b.0).then_with(|| a.1.1.cmp(&b.1.1)));
 
     for (_provider, (provider_id, model_name, _effort)) in candidates {
         let model_id = format!("{}@{}", provider_id, model_name);
@@ -299,7 +299,7 @@ pub fn parse_and_validate_model(
     let id_str = model_id.0.as_ref();
     let (provider_id, model_name) = id_str
         .split_once('@')
-        .map(|(p, m)| (p.to_string(), m.to_string()))?;
+        .map(|(p, m)| (p.to_owned(), m.to_owned()))?;
 
     // Validate that the provider exists
     if !config.model_providers.contains_key(&provider_id) {
diff --git a/src/fs/bridge.rs b/src/fs/bridge.rs
@@ -279,12 +279,14 @@ impl FsBridgeInner {
             Some(start_line) => {
                 let start = start_line.saturating_sub(1) as usize;
                 let count = limit.unwrap_or(u32::MAX) as usize;
-                let lines: Vec<&str> = content.lines().collect();
-                if start >= lines.len() {
+
+                // Efficient line slicing: skip + take to avoid collecting all lines
+                let selected_lines: Vec<&str> = content.lines().skip(start).take(count).collect();
+
+                if selected_lines.is_empty() {
                     Ok(String::new())
                 } else {
-                    let end = (start + count).min(lines.len());
-                    Ok(lines[start..end].join("\n"))
+                    Ok(selected_lines.join("\n"))
                 }
             }
             None => Ok(content),
diff --git a/src/fs/mcp_server.rs b/src/fs/mcp_server.rs
@@ -7,7 +7,7 @@ use std::{
     },
 };
 
-use anyhow::{Context, Result, anyhow};
+use anyhow::{Context, Result, anyhow, bail};
 use diffy::{PatchFormatter, create_patch};
 use rmcp::{
     ErrorData as McpError, ServerHandler,
@@ -178,15 +178,15 @@ impl FsTools {
         });
 
         if truncated && let Some(obj) = meta.as_object_mut() {
-            obj.insert("next_line".to_string(), json!(end_line.saturating_add(1)));
+            obj.insert("next_line".into(), json!(end_line.saturating_add(1)));
         }
 
         if truncated_by_bytes && let Some(obj) = meta.as_object_mut() {
-            obj.insert("max_bytes".to_string(), json!(MAX_READ_BYTES));
+            obj.insert("max_bytes".into(), json!(MAX_READ_BYTES));
         }
 
         let mut meta_obj = Meta::new();
-        meta_obj.insert("codex_fs_read".to_string(), meta);
+        meta_obj.insert("codex_fs_read".into(), meta);
         let content = RawContent::Text(RawTextContent {
             text,
             meta: Some(meta_obj),
@@ -310,9 +310,9 @@ impl ServerHandler for FsTools {
             protocol_version: ProtocolVersion::default(),
             capabilities: caps,
             server_info: Implementation {
-                name: "codex-acp-fs".to_string(),
-                title: Some("Codex ACP Filesystem".to_string()),
-                version: env!("CARGO_PKG_VERSION").to_string(),
+                name: "codex-acp-fs".into(),
+                title: Some("Codex ACP Filesystem".into()),
+                version: env!("CARGO_PKG_VERSION").into(),
                 icons: None,
                 website_url: None,
             },
@@ -429,7 +429,7 @@ async fn stage_edits(
         )
     })?;
 
-    staged_edits.stage(path.to_string(), write_content).await;
+    staged_edits.stage(path.to_owned(), write_content).await;
     info!(file = %path, bytes = staged_bytes, "Staged edits committed");
 
     let (new_ranges, old_ranges) = parse_diff_line_ranges(&diff_text);
@@ -440,7 +440,7 @@ async fn stage_edits(
     });
 
     let mut meta_obj = Meta::new();
-    meta_obj.insert("codex_fs_diff".to_string(), diff_meta);
+    meta_obj.insert("codex_fs_diff".into(), diff_meta);
     let diff_content = RawContent::Text(RawTextContent {
         text: diff_text,
         meta: Some(meta_obj),
@@ -453,27 +453,25 @@ async fn stage_edits(
 }
 
 fn apply_edits(base: &str, edits: &[EditInstruction]) -> Result<String> {
-    let mut content = base.to_string();
+    let mut content = base.to_owned();
     for edit in edits {
         if edit.old_text.is_empty() {
-            return Err(anyhow!(
-                "the provided `old_string` is empty. No edits were applied."
-            ));
+            bail!("the provided `old_string` is empty. No edits were applied.")
         }
 
         if edit.replace_all {
             let replaced = content.replace(&edit.old_text, &edit.new_text);
             if replaced == content {
-                return Err(anyhow!(
+                bail!(
                     "The provided `old_string` does not appear in the file. No edits were applied."
-                ));
+                )
             }
             content = replaced;
         } else {
             let Some(index) = content.find(&edit.old_text) else {
-                return Err(anyhow!(
+                bail!(
                     "The provided `old_string` does not appear in the file. No edits were applied."
-                ));
+                )
             };
             let end = index + edit.old_text.len();
             content.replace_range(index..end, &edit.new_text);
diff --git a/src/main.rs b/src/main.rs
@@ -6,6 +6,7 @@ use codex_acp::{
 use agent_client_protocol::{AgentSideConnection, Client, Error};
 use anyhow::{Result, bail};
 use codex_core::config::{self, Config};
+use codex_utils_absolute_path::AbsolutePathBuf;
 use std::env;
 use tokio::{
     io,
@@ -31,21 +32,21 @@ async fn main() -> Result<()> {
         let (tx, mut rx) = mpsc::unbounded_channel();
         let (client_tx, mut client_rx) = mpsc::unbounded_channel();
 
-        // Config loading strategy:
-        // 1. Load Config first (contains resolved runtime settings)
-        // 2. Load ConfigToml to extract profiles (needed for model/mode switching)
-        //
-        // NOTE: This results in two file reads/parses. Optimizations:
-        // - We reuse config.codex_home instead of calling find_codex_home() twice
-        // - We take ownership of profiles instead of cloning
-        // - Future: codex_core could expose profiles from Config to eliminate second load
+        // Load config and profiles in a single pass to avoid redundant I/O.
+        // We load the TOML first to get profiles, then construct Config from it.
         let config = Config::load_with_cli_overrides(vec![]).await?;
+        let cwd_abs = AbsolutePathBuf::from_absolute_path(&config.cwd)
+            .map_err(|e| anyhow::anyhow!("failed to resolve absolute path for cwd: {}", e))?;
+
         let config_toml = config::load_config_as_toml_with_cli_overrides(
             &config.codex_home,
+            &cwd_abs,
             vec![],
         ).await?;
+
         let profiles = config_toml.profiles;
-        let fs_bridge = FsBridge::start(client_tx.clone(), config.cwd.clone()).await?;
+        let cwd_path = config.cwd.clone();
+        let fs_bridge = FsBridge::start(client_tx.clone(), cwd_path).await?;
         let agent = CodexAgent::with_config(tx, client_tx, config, profiles, Some(fs_bridge));
         let session_manager = agent.session_manager().clone();
         let (conn, handle_io) = AgentSideConnection::new(agent, outgoing, incoming, |fut| {

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ impl CodexAgent {`
`19`	`19`	`items: vec![UserInput::Text {`
`20`	`20`	`text: prompt.into(),`
`21`	`21`	`}],`
	`22`	`+ final_output_json_schema: None,`
`22`	`23`	`})`
`23`	`24`	`}`
`24`	`25`	`"status" => {`