Propagate tool errors to code mode (#15075)

Clean up error flow to push the FunctionCallError all the way up to
dispatcher and allow code mode to surface as exception.

codex-rs/core/src/tools/code_mode/mod.rs

@@ -14,6 +14,7 @@ use serde_json::Value as JsonValue;
 use crate::client_common::tools::ToolSpec;
 use crate::codex::Session;
 use crate::codex::TurnContext;
+use crate::function_tool::FunctionCallError;
 use crate::tools::ToolRouter;
 use crate::tools::code_mode_description::augment_tool_spec_for_code_mode;
 use crate::tools::code_mode_description::code_mode_tool_reference;
@@ -303,9 +304,11 @@ async fn call_nested_tool(
     tool_name: String,
     input: Option<JsonValue>,
     cancellation_token: tokio_util::sync::CancellationToken,
-) -> JsonValue {
+) -> Result<JsonValue, FunctionCallError> {
     if tool_name == PUBLIC_TOOL_NAME {
-        return JsonValue::String(format!("{PUBLIC_TOOL_NAME} cannot invoke itself"));
+        return Err(FunctionCallError::RespondToModel(format!(
+            "{PUBLIC_TOOL_NAME} cannot invoke itself"
+        )));
     }
 
     let payload =
@@ -316,12 +319,12 @@ async fn call_nested_tool(
                     tool,
                     raw_arguments,
                 },
-                Err(error) => return JsonValue::String(error),
+                Err(error) => return Err(FunctionCallError::RespondToModel(error)),
             }
         } else {
             match build_nested_tool_payload(tool_runtime.find_spec(&tool_name), &tool_name, input) {
                 Ok(payload) => payload,
-                Err(error) => return JsonValue::String(error),
+                Err(error) => return Err(FunctionCallError::RespondToModel(error)),
             }
         };
 
@@ -333,12 +336,8 @@ async fn call_nested_tool(
     };
     let result = tool_runtime
         .handle_tool_call_with_source(call, ToolCallSource::CodeMode, cancellation_token)
-        .await;
-
-    match result {
-        Ok(result) => result.code_mode_result(),
-        Err(error) => JsonValue::String(error.to_string()),
-    }
+        .await?;
+    Ok(result.code_mode_result())
 }
 
 fn tool_kind_for_spec(spec: &ToolSpec) -> protocol::CodeModeToolKind {

codex-rs/core/src/tools/code_mode/protocol.rs

@@ -70,6 +70,8 @@ pub(super) enum HostToNodeMessage {
         request_id: String,
         id: String,
         code_mode_result: JsonValue,
+        #[serde(default)]
+        error_text: Option<String>,
     },
 }
 

codex-rs/core/src/tools/code_mode/runner.cjs

@@ -595,6 +595,10 @@ function createProtocol() {
         return;
       }
       pending.delete(message.request_id + ':' + message.id);
+      if (typeof message.error_text === 'string') {
+        entry.reject(new Error(message.error_text));
+        return;
+      }
       entry.resolve(message.code_mode_result ?? '');
       return;
     }

codex-rs/core/src/tools/code_mode/worker.rs

@@ -14,6 +14,7 @@ use super::process::write_message;
 use super::protocol::HostToNodeMessage;
 use super::protocol::NodeToHostMessage;
 use crate::tools::parallel::ToolCallRuntime;
+
 pub(crate) struct CodeModeWorker {
     shutdown_tx: Option<oneshot::Sender<()>>,
 }
@@ -53,17 +54,23 @@ impl CodeModeProcess {
                         let tool_runtime = tool_runtime.clone();
                         let stdin = stdin.clone();
                         tokio::spawn(async move {
+                            let result = call_nested_tool(
+                                exec,
+                                tool_runtime,
+                                tool_call.name,
+                                tool_call.input,
+                                CancellationToken::new(),
+                            )
+                            .await;
+                            let (code_mode_result, error_text) = match result {
+                                Ok(code_mode_result) => (code_mode_result, None),
+                                Err(error) => (serde_json::Value::Null, Some(error.to_string())),
+                            };
                             let response = HostToNodeMessage::Response {
                                 request_id: tool_call.request_id,
                                 id: tool_call.id,
-                                code_mode_result: call_nested_tool(
-                                    exec,
-                                    tool_runtime,
-                                    tool_call.name,
-                                    tool_call.input,
-                                    CancellationToken::new(),
-                                )
-                                .await,
+                                code_mode_result,
+                                error_text,
                             };
                             if let Err(err) = write_message(&stdin, &response).await {
                                 warn!("failed to write {PUBLIC_TOOL_NAME} tool response: {err}");