Add approved dynamic tool arguments steering

codex-rs/app-server-protocol/schema/json/DynamicToolCallResponse.json

@@ -47,6 +47,9 @@
     }
   },
   "properties": {
+    "approvedArguments": {
+      "description": "Optional client-approved replacement arguments. When present, this must fully match the existing registered schema for the same dynamic tool."
+    },
     "contentItems": {
       "items": {
         "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -63,4 +66,4 @@
   ],
   "title": "DynamicToolCallResponse",
   "type": "object"
-}
+}

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json

@@ -1853,6 +1853,9 @@
     "DynamicToolCallResponse": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {
+        "approvedArguments": {
+          "description": "Optional client-approved replacement arguments. When present, this must fully match the existing registered schema for the same dynamic tool."
+        },
         "contentItems": {
           "items": {
             "$ref": "#/definitions/v2/DynamicToolCallOutputContentItem"
@@ -14491,4 +14494,4 @@
   },
   "title": "CodexAppServerProtocol",
   "type": "object"
-}
+}

codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolCallResponse.ts

@@ -1,6 +1,12 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "../serde_json/JsonValue";
 import type { DynamicToolCallOutputContentItem } from "./DynamicToolCallOutputContentItem";
 
-export type DynamicToolCallResponse = { contentItems: Array<DynamicToolCallOutputContentItem>, success: boolean, };
+export type DynamicToolCallResponse = { contentItems: Array<DynamicToolCallOutputContentItem>, success: boolean, 
+/**
+ * Optional client-approved replacement arguments. When present, this must
+ * fully match the existing registered schema for the same dynamic tool.
+ */
+approvedArguments: JsonValue | null, };

codex-rs/app-server-protocol/src/protocol/thread_history.rs

@@ -1802,6 +1802,65 @@ mod tests {
         );
     }
 
+    #[test]
+    fn reconstructs_dynamic_tool_items_using_authoritative_response_arguments() {
+        let events = vec![
+            EventMsg::TurnStarted(TurnStartedEvent {
+                turn_id: "turn-1".into(),
+                model_context_window: None,
+                collaboration_mode_kind: Default::default(),
+            }),
+            EventMsg::UserMessage(UserMessageEvent {
+                message: "run dynamic tool".into(),
+                images: None,
+                text_elements: Vec::new(),
+                local_images: Vec::new(),
+            }),
+            EventMsg::DynamicToolCallRequest(
+                codex_protocol::dynamic_tools::DynamicToolCallRequest {
+                    call_id: "dyn-1".into(),
+                    turn_id: "turn-1".into(),
+                    tool: "lookup_ticket".into(),
+                    arguments: serde_json::json!({"id":"ABC-123"}),
+                },
+            ),
+            EventMsg::DynamicToolCallResponse(DynamicToolCallResponseEvent {
+                call_id: "dyn-1".into(),
+                turn_id: "turn-1".into(),
+                tool: "lookup_ticket".into(),
+                arguments: serde_json::json!({"id":"ABC-456"}),
+                content_items: vec![CoreDynamicToolCallOutputContentItem::InputText {
+                    text: "Ticket is open".into(),
+                }],
+                success: true,
+                error: None,
+                duration: Duration::from_millis(42),
+            }),
+        ];
+
+        let items = events
+            .into_iter()
+            .map(RolloutItem::EventMsg)
+            .collect::<Vec<_>>();
+        let turns = build_turns_from_rollout_items(&items);
+        assert_eq!(turns.len(), 1);
+        assert_eq!(turns[0].items.len(), 2);
+        assert_eq!(
+            turns[0].items[1],
+            ThreadItem::DynamicToolCall {
+                id: "dyn-1".into(),
+                tool: "lookup_ticket".into(),
+                arguments: serde_json::json!({"id":"ABC-456"}),
+                status: DynamicToolCallStatus::Completed,
+                content_items: Some(vec![DynamicToolCallOutputContentItem::InputText {
+                    text: "Ticket is open".into(),
+                }]),
+                success: Some(true),
+                duration_ms: Some(42),
+            }
+        );
+    }
+
     #[test]
     fn reconstructs_declined_exec_and_patch_items() {
         let events = vec![

codex-rs/app-server-protocol/src/protocol/v2.rs

@@ -5634,6 +5634,9 @@ pub struct PermissionsRequestApprovalResponse {
 pub struct DynamicToolCallResponse {
     pub content_items: Vec<DynamicToolCallOutputContentItem>,
     pub success: bool,
+    /// Optional client-approved replacement arguments. When present, this must
+    /// fully match the existing registered schema for the same dynamic tool.
+    pub approved_arguments: Option<JsonValue>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -7640,6 +7643,7 @@ mod tests {
                 text: "dynamic-ok".to_string(),
             }],
             success: true,
+            approved_arguments: None,
         })
         .unwrap();
 
@@ -7652,6 +7656,7 @@ mod tests {
                         "text": "dynamic-ok"
                     }
                 ],
+                "approvedArguments": null,
                 "success": true,
             })
         );
@@ -7669,6 +7674,7 @@ mod tests {
                 },
             ],
             success: true,
+            approved_arguments: None,
         })
         .unwrap();
 
@@ -7685,11 +7691,51 @@ mod tests {
                         "imageUrl": "data:image/png;base64,AAA"
                     }
                 ],
+                "approvedArguments": null,
                 "success": true,
             })
         );
     }
 
+    #[test]
+    fn dynamic_tool_response_round_trips_non_null_approved_arguments() {
+        let value = serde_json::to_value(DynamicToolCallResponse {
+            content_items: vec![DynamicToolCallOutputContentItem::InputText {
+                text: "dynamic-ok".to_string(),
+            }],
+            success: true,
+            approved_arguments: Some(json!({ "city": "Tokyo" })),
+        })
+        .unwrap();
+
+        assert_eq!(
+            value,
+            json!({
+                "contentItems": [
+                    {
+                        "type": "inputText",
+                        "text": "dynamic-ok"
+                    }
+                ],
+                "approvedArguments": {
+                    "city": "Tokyo"
+                },
+                "success": true,
+            })
+        );
+
+        assert_eq!(
+            serde_json::from_value::<DynamicToolCallResponse>(value).unwrap(),
+            DynamicToolCallResponse {
+                content_items: vec![DynamicToolCallOutputContentItem::InputText {
+                    text: "dynamic-ok".to_string(),
+                }],
+                success: true,
+                approved_arguments: Some(json!({ "city": "Tokyo" })),
+            }
+        );
+    }
+
     #[test]
     fn dynamic_tool_spec_deserializes_defer_loading() {
         let value = json!({

codex-rs/app-server/README.md

@@ -1027,11 +1027,21 @@ The client must respond with content items. Use `inputText` for text and `inputI
       { "type": "inputText", "text": "Ticket ABC-123 is open." },
       { "type": "inputImage", "imageUrl": "data:image/png;base64,AAA" }
     ],
-    "success": true
+    "success": true,
+    "approvedArguments": { "id": "ABC-456" }
   }
 }
 ```
 
+`approvedArguments` is optional. When omitted or `null`, the original model-proposed `arguments` remain authoritative. When present, it must be a full replacement object/value that still matches the same registered dynamic-tool schema; clients cannot rename the tool or change its schema.
+
+Event semantics stay narrow:
+
+1. `item/started` and `item/tool/call` always show the model-proposed arguments.
+2. If the client returns valid `approvedArguments`, Codex treats them as the authoritative executed arguments.
+3. `item/completed` uses the authoritative final arguments.
+4. When the authoritative arguments differ from the proposed ones, Codex records a developer-role note so the next model step reasons from the approved arguments instead of the earlier proposal.
+
 ## Skills
 
 Invoke a skill by including `$<skill-name>` in the text input. Add a `skill` input item (recommended) so the backend injects full skill instructions instead of relying on the model to resolve the name.

codex-rs/app-server/src/bespoke_event_handling.rs

@@ -862,6 +862,7 @@ pub(crate) async fn apply_bespoke_event_handling(
                                 text: "dynamic tool calls require api v2".to_string(),
                             }],
                             success: false,
+                            approved_arguments: None,
                         },
                     })
                     .await;

codex-rs/app-server/src/dynamic_tools.rs

@@ -33,13 +33,15 @@ pub(crate) async fn on_call_response(
     let DynamicToolCallResponse {
         content_items,
         success,
+        approved_arguments,
     } = response.clone();
     let core_response = CoreDynamicToolResponse {
         content_items: content_items
             .into_iter()
             .map(CoreDynamicToolCallOutputContentItem::from)
             .collect(),
         success,
+        approved_arguments,
     };
     if let Err(err) = conversation
         .submit(Op::DynamicToolResponse {
@@ -69,6 +71,7 @@ fn fallback_response(message: &str) -> (DynamicToolCallResponse, Option<String>)
                 text: message.to_string(),
             }],
             success: false,
+            approved_arguments: None,
         },
         Some(message.to_string()),
     )