mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## Why This is the next stacked step after deleting the tool-handler kind indirection. Specs should come from the registered handlers themselves so registry construction has a single source of truth for handler behavior and exposed tool definitions. ## What changed - Added `ToolHandler::spec()` plus handler-provided parallel/code-mode metadata, and made `ToolRegistryBuilder::register_handler` automatically collect specs from registered handlers. - Moved builtin tool spec construction into the corresponding handlers and their adjacent `_spec` modules, including shell, unified exec, apply patch, view image, request plugin install, tool search, MCP resource, goals, planning, permissions, agent jobs, and multi-agent tools. - Reworked configurable handlers to receive their tool-building options through constructors, with non-optional handler options where the handler is always spec-backed. Shell fallback handlers keep an explicit no-spec mode because they are also registered as hidden dispatch aliases. - Kept `CodeModeExecuteHandler` on the explicit configured wrapper so the code-mode exec spec can still be built from the nested registry. ## Verification - `cargo check -p codex-core` - `cargo test -p codex-core tools::spec_plan::tests` - `cargo test -p codex-core tools::spec::tests` - `cargo test -p codex-core tools::handlers::multi_agents_spec::tests` - `RUST_MIN_STACK=16777216 cargo test -p codex-core tools::handlers::multi_agents::tests` - `cargo test -p codex-core tools::handlers::apply_patch::tests` - `cargo test -p codex-core tools::handlers::unified_exec::tests` - `just fix -p codex-core` - `git diff --check`
100 lines
2.9 KiB
Rust
100 lines
2.9 KiB
Rust
use crate::function_tool::FunctionCallError;
|
|
use crate::tools::context::ToolInvocation;
|
|
use crate::tools::context::ToolOutput;
|
|
use crate::tools::context::ToolPayload;
|
|
use crate::tools::handlers::plan_spec::create_update_plan_tool;
|
|
use crate::tools::registry::ToolHandler;
|
|
use crate::tools::registry::ToolKind;
|
|
use codex_protocol::config_types::ModeKind;
|
|
use codex_protocol::models::FunctionCallOutputPayload;
|
|
use codex_protocol::models::ResponseInputItem;
|
|
use codex_protocol::plan_tool::UpdatePlanArgs;
|
|
use codex_protocol::protocol::EventMsg;
|
|
use codex_tools::ToolName;
|
|
use codex_tools::ToolSpec;
|
|
use serde_json::Value as JsonValue;
|
|
|
|
pub struct PlanHandler;
|
|
|
|
pub struct PlanToolOutput;
|
|
|
|
const PLAN_UPDATED_MESSAGE: &str = "Plan updated";
|
|
|
|
impl ToolOutput for PlanToolOutput {
|
|
fn log_preview(&self) -> String {
|
|
PLAN_UPDATED_MESSAGE.to_string()
|
|
}
|
|
|
|
fn success_for_logging(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn to_response_item(&self, call_id: &str, _payload: &ToolPayload) -> ResponseInputItem {
|
|
let mut output = FunctionCallOutputPayload::from_text(PLAN_UPDATED_MESSAGE.to_string());
|
|
output.success = Some(true);
|
|
|
|
ResponseInputItem::FunctionCallOutput {
|
|
call_id: call_id.to_string(),
|
|
output,
|
|
}
|
|
}
|
|
|
|
fn code_mode_result(&self, _payload: &ToolPayload) -> JsonValue {
|
|
JsonValue::Object(serde_json::Map::new())
|
|
}
|
|
}
|
|
|
|
impl ToolHandler for PlanHandler {
|
|
type Output = PlanToolOutput;
|
|
|
|
fn tool_name(&self) -> ToolName {
|
|
ToolName::plain("update_plan")
|
|
}
|
|
|
|
fn spec(&self) -> Option<ToolSpec> {
|
|
Some(create_update_plan_tool())
|
|
}
|
|
|
|
fn kind(&self) -> ToolKind {
|
|
ToolKind::Function
|
|
}
|
|
|
|
async fn handle(&self, invocation: ToolInvocation) -> Result<Self::Output, FunctionCallError> {
|
|
let ToolInvocation {
|
|
session,
|
|
turn,
|
|
call_id: _,
|
|
payload,
|
|
..
|
|
} = invocation;
|
|
|
|
let arguments = match payload {
|
|
ToolPayload::Function { arguments } => arguments,
|
|
_ => {
|
|
return Err(FunctionCallError::RespondToModel(
|
|
"update_plan handler received unsupported payload".to_string(),
|
|
));
|
|
}
|
|
};
|
|
|
|
if turn.collaboration_mode.mode == ModeKind::Plan {
|
|
return Err(FunctionCallError::RespondToModel(
|
|
"update_plan is a TODO/checklist tool and is not allowed in Plan mode".to_string(),
|
|
));
|
|
}
|
|
|
|
let args = parse_update_plan_arguments(&arguments)?;
|
|
session
|
|
.send_event(turn.as_ref(), EventMsg::PlanUpdate(args))
|
|
.await;
|
|
|
|
Ok(PlanToolOutput)
|
|
}
|
|
}
|
|
|
|
fn parse_update_plan_arguments(arguments: &str) -> Result<UpdatePlanArgs, FunctionCallError> {
|
|
serde_json::from_str::<UpdatePlanArgs>(arguments).map_err(|e| {
|
|
FunctionCallError::RespondToModel(format!("failed to parse function arguments: {e}"))
|
|
})
|
|
}
|