diff --git a/codex-rs/app-server-protocol/src/protocol/thread_history.rs b/codex-rs/app-server-protocol/src/protocol/thread_history.rs index 6772d6f92a..e6c679b418 100644 --- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs +++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs @@ -197,8 +197,12 @@ impl ThreadHistoryBuilder { if !payload.message.trim().is_empty() { content.push(UserInput::Text { text: payload.message.clone(), - // TODO: Thread text element ranges into thread history. Empty keeps old behavior. - text_elements: Vec::new(), + text_elements: payload + .text_elements + .iter() + .cloned() + .map(Into::into) + .collect(), }); } if let Some(images) = &payload.images { @@ -206,6 +210,9 @@ impl ThreadHistoryBuilder { content.push(UserInput::Image { url: image.clone() }); } } + for path in &payload.local_images { + content.push(UserInput::LocalImage { path: path.clone() }); + } content } } diff --git a/codex-rs/app-server-protocol/src/protocol/v1.rs b/codex-rs/app-server-protocol/src/protocol/v1.rs index ecc9d7c07d..a5bc69be5d 100644 --- a/codex-rs/app-server-protocol/src/protocol/v1.rs +++ b/codex-rs/app-server-protocol/src/protocol/v1.rs @@ -16,6 +16,8 @@ use codex_protocol::protocol::ReviewDecision; use codex_protocol::protocol::SandboxPolicy; use codex_protocol::protocol::SessionSource; use codex_protocol::protocol::TurnAbortReason; +use codex_protocol::user_input::ByteRange as CoreByteRange; +use codex_protocol::user_input::TextElement as CoreTextElement; use codex_utils_absolute_path::AbsolutePathBuf; use schemars::JsonSchema; use serde::Deserialize; @@ -444,9 +446,74 @@ pub struct RemoveConversationListenerParams { #[serde(rename_all = "camelCase")] #[serde(tag = "type", content = "data")] pub enum InputItem { - Text { text: String }, - Image { image_url: String }, - LocalImage { path: PathBuf }, + Text { + text: String, + /// UI-defined spans within `text` used to render or persist special elements. + #[serde(default)] + text_elements: Vec, + }, + Image { + image_url: String, + }, + LocalImage { + path: PathBuf, + }, +} + +#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(rename = "ByteRange")] +pub struct V1ByteRange { + /// Start byte offset (inclusive) within the UTF-8 text buffer. + pub start: usize, + /// End byte offset (exclusive) within the UTF-8 text buffer. + pub end: usize, +} + +impl From for V1ByteRange { + fn from(value: CoreByteRange) -> Self { + Self { + start: value.start, + end: value.end, + } + } +} + +impl From for CoreByteRange { + fn from(value: V1ByteRange) -> Self { + Self { + start: value.start, + end: value.end, + } + } +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(rename = "TextElement")] +pub struct V1TextElement { + /// Byte range in the parent `text` buffer that this element occupies. + pub byte_range: V1ByteRange, + /// Optional human-readable placeholder for the element, displayed in the UI. + pub placeholder: Option, +} + +impl From for V1TextElement { + fn from(value: CoreTextElement) -> Self { + Self { + byte_range: value.byte_range.into(), + placeholder: value.placeholder, + } + } +} + +impl From for CoreTextElement { + fn from(value: V1TextElement) -> Self { + Self { + byte_range: value.byte_range.into(), + placeholder: value.placeholder, + } + } } #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] diff --git a/codex-rs/app-server-protocol/src/protocol/v2.rs b/codex-rs/app-server-protocol/src/protocol/v2.rs index d8a0e8a6e6..ac930e1f42 100644 --- a/codex-rs/app-server-protocol/src/protocol/v2.rs +++ b/codex-rs/app-server-protocol/src/protocol/v2.rs @@ -16,6 +16,7 @@ use codex_protocol::openai_models::ReasoningEffort; use codex_protocol::parse_command::ParsedCommand as CoreParsedCommand; use codex_protocol::plan_tool::PlanItemArg as CorePlanItemArg; use codex_protocol::plan_tool::StepStatus as CorePlanStepStatus; +use codex_protocol::protocol::AgentStatus as CoreAgentStatus; use codex_protocol::protocol::AskForApproval as CoreAskForApproval; use codex_protocol::protocol::CodexErrorInfo as CoreCodexErrorInfo; use codex_protocol::protocol::CreditsSnapshot as CoreCreditsSnapshot; @@ -24,10 +25,13 @@ use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot; use codex_protocol::protocol::RateLimitWindow as CoreRateLimitWindow; use codex_protocol::protocol::SessionSource as CoreSessionSource; use codex_protocol::protocol::SkillErrorInfo as CoreSkillErrorInfo; +use codex_protocol::protocol::SkillInterface as CoreSkillInterface; use codex_protocol::protocol::SkillMetadata as CoreSkillMetadata; use codex_protocol::protocol::SkillScope as CoreSkillScope; use codex_protocol::protocol::TokenUsage as CoreTokenUsage; use codex_protocol::protocol::TokenUsageInfo as CoreTokenUsageInfo; +use codex_protocol::user_input::ByteRange as CoreByteRange; +use codex_protocol::user_input::TextElement as CoreTextElement; use codex_protocol::user_input::UserInput as CoreUserInput; use codex_utils_absolute_path::AbsolutePathBuf; use mcp_types::ContentBlock as McpContentBlock; @@ -1251,13 +1255,35 @@ pub enum SkillScope { pub struct SkillMetadata { pub name: String, pub description: String, - #[ts(optional)] #[serde(default, skip_serializing_if = "Option::is_none")] + #[ts(optional)] + /// Legacy short_description from SKILL.md. Prefer SKILL.toml interface.short_description. pub short_description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[ts(optional)] + pub interface: Option, pub path: PathBuf, pub scope: SkillScope, } +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub struct SkillInterface { + #[ts(optional)] + pub display_name: Option, + #[ts(optional)] + pub short_description: Option, + #[ts(optional)] + pub icon_small: Option, + #[ts(optional)] + pub icon_large: Option, + #[ts(optional)] + pub brand_color: Option, + #[ts(optional)] + pub default_prompt: Option, +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] @@ -1281,12 +1307,26 @@ impl From for SkillMetadata { name: value.name, description: value.description, short_description: value.short_description, + interface: value.interface.map(SkillInterface::from), path: value.path, scope: value.scope.into(), } } } +impl From for SkillInterface { + fn from(value: CoreSkillInterface) -> Self { + Self { + display_name: value.display_name, + short_description: value.short_description, + brand_color: value.brand_color, + default_prompt: value.default_prompt, + icon_small: value.icon_small, + icon_large: value.icon_large, + } + } +} + impl From for SkillScope { fn from(value: CoreSkillScope) -> Self { match value { @@ -1551,6 +1591,24 @@ pub struct ByteRange { pub end: usize, } +impl From for ByteRange { + fn from(value: CoreByteRange) -> Self { + Self { + start: value.start, + end: value.end, + } + } +} + +impl From for CoreByteRange { + fn from(value: ByteRange) -> Self { + Self { + start: value.start, + end: value.end, + } + } +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] @@ -1561,6 +1619,24 @@ pub struct TextElement { pub placeholder: Option, } +impl From for TextElement { + fn from(value: CoreTextElement) -> Self { + Self { + byte_range: value.byte_range.into(), + placeholder: value.placeholder, + } + } +} + +impl From for CoreTextElement { + fn from(value: TextElement) -> Self { + Self { + byte_range: value.byte_range.into(), + placeholder: value.placeholder, + } + } +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(tag = "type", rename_all = "camelCase")] #[ts(tag = "type")] @@ -1587,10 +1663,12 @@ pub enum UserInput { impl UserInput { pub fn into_core(self) -> CoreUserInput { match self { - UserInput::Text { text, .. } => CoreUserInput::Text { + UserInput::Text { text, - // TODO: Thread text element ranges into v2 inputs. Empty keeps old behavior. - text_elements: Vec::new(), + text_elements, + } => CoreUserInput::Text { + text, + text_elements: text_elements.into_iter().map(Into::into).collect(), }, UserInput::Image { url } => CoreUserInput::Image { image_url: url }, UserInput::LocalImage { path } => CoreUserInput::LocalImage { path }, @@ -1602,10 +1680,12 @@ impl UserInput { impl From for UserInput { fn from(value: CoreUserInput) -> Self { match value { - CoreUserInput::Text { text, .. } => UserInput::Text { + CoreUserInput::Text { text, - // TODO: Thread text element ranges from core into v2 inputs. - text_elements: Vec::new(), + text_elements, + } => UserInput::Text { + text, + text_elements: text_elements.into_iter().map(Into::into).collect(), }, CoreUserInput::Image { image_url } => UserInput::Image { url: image_url }, CoreUserInput::LocalImage { path } => UserInput::LocalImage { path }, @@ -1681,6 +1761,25 @@ pub enum ThreadItem { }, #[serde(rename_all = "camelCase")] #[ts(rename_all = "camelCase")] + CollabAgentToolCall { + /// Unique identifier for this collab tool call. + id: String, + /// Name of the collab tool that was invoked. + tool: CollabAgentTool, + /// Current status of the collab tool call. + status: CollabAgentToolCallStatus, + /// Thread ID of the agent issuing the collab request. + sender_thread_id: String, + /// Thread ID of the receiving agent, when applicable. In case of spawn operation, + /// this correspond to the newly spawned agent. + receiver_thread_id: Option, + /// Prompt text sent as part of the collab tool call, when available. + prompt: Option, + /// Last known status of the target agent, when available. + agent_state: Option, + }, + #[serde(rename_all = "camelCase")] + #[ts(rename_all = "camelCase")] WebSearch { id: String, query: String }, #[serde(rename_all = "camelCase")] #[ts(rename_all = "camelCase")] @@ -1733,6 +1832,16 @@ pub enum CommandExecutionStatus { Declined, } +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub enum CollabAgentTool { + SpawnAgent, + SendInput, + Wait, + CloseAgent, +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] @@ -1771,6 +1880,66 @@ pub enum McpToolCallStatus { Failed, } +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub enum CollabAgentToolCallStatus { + InProgress, + Completed, + Failed, +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub enum CollabAgentStatus { + PendingInit, + Running, + Completed, + Errored, + Shutdown, + NotFound, +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub struct CollabAgentState { + pub status: CollabAgentStatus, + pub message: Option, +} + +impl From for CollabAgentState { + fn from(value: CoreAgentStatus) -> Self { + match value { + CoreAgentStatus::PendingInit => Self { + status: CollabAgentStatus::PendingInit, + message: None, + }, + CoreAgentStatus::Running => Self { + status: CollabAgentStatus::Running, + message: None, + }, + CoreAgentStatus::Completed(message) => Self { + status: CollabAgentStatus::Completed, + message, + }, + CoreAgentStatus::Errored(message) => Self { + status: CollabAgentStatus::Errored, + message: Some(message), + }, + CoreAgentStatus::Shutdown => Self { + status: CollabAgentStatus::Shutdown, + message: None, + }, + CoreAgentStatus::NotFound => Self { + status: CollabAgentStatus::NotFound, + message: None, + }, + } + } +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] diff --git a/codex-rs/app-server-test-client/src/main.rs b/codex-rs/app-server-test-client/src/main.rs index 809c2b5a33..9df895a70a 100644 --- a/codex-rs/app-server-test-client/src/main.rs +++ b/codex-rs/app-server-test-client/src/main.rs @@ -477,6 +477,7 @@ impl CodexClient { conversation_id: *conversation_id, items: vec![InputItem::Text { text: message.to_string(), + text_elements: Vec::new(), }], }, }; diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.md index 26c2dee9cf..63f4dea965 100644 --- a/codex-rs/app-server/README.md +++ b/codex-rs/app-server/README.md @@ -375,6 +375,7 @@ Today both notifications carry an empty `items` array even when item events were - `commandExecution` — `{id, command, cwd, status, commandActions, aggregatedOutput?, exitCode?, durationMs?}` for sandboxed commands; `status` is `inProgress`, `completed`, `failed`, or `declined`. - `fileChange` — `{id, changes, status}` describing proposed edits; `changes` list `{path, kind, diff}` and `status` is `inProgress`, `completed`, `failed`, or `declined`. - `mcpToolCall` — `{id, server, tool, status, arguments, result?, error?}` describing MCP calls; `status` is `inProgress`, `completed`, or `failed`. +- `collabToolCall` — `{id, tool, status, senderThreadId, receiverThreadId?, newThreadId?, prompt?, agentStatus?}` describing collab tool calls (`spawn_agent`, `send_input`, `wait`, `close_agent`); `status` is `inProgress`, `completed`, or `failed`. - `webSearch` — `{id, query}` for a web search request issued by the agent. - `imageView` — `{id, path}` emitted when the agent invokes the image viewer tool. - `enteredReviewMode` — `{id, review}` sent when the reviewer starts; `review` is a short user-facing label such as `"current changes"` or the requested target description. diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 0870191ec8..f14dd2ddca 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -14,6 +14,9 @@ use codex_app_server_protocol::AgentMessageDeltaNotification; use codex_app_server_protocol::ApplyPatchApprovalParams; use codex_app_server_protocol::ApplyPatchApprovalResponse; use codex_app_server_protocol::CodexErrorInfo as V2CodexErrorInfo; +use codex_app_server_protocol::CollabAgentState as V2CollabAgentStatus; +use codex_app_server_protocol::CollabAgentTool; +use codex_app_server_protocol::CollabAgentToolCallStatus as V2CollabToolCallStatus; use codex_app_server_protocol::CommandAction as V2ParsedCommand; use codex_app_server_protocol::CommandExecutionApprovalDecision; use codex_app_server_protocol::CommandExecutionOutputDeltaNotification; @@ -278,6 +281,178 @@ pub(crate) async fn apply_bespoke_event_handling( .send_server_notification(ServerNotification::ItemCompleted(notification)) .await; } + EventMsg::CollabAgentSpawnBegin(begin_event) => { + let item = ThreadItem::CollabAgentToolCall { + id: begin_event.call_id, + tool: CollabAgentTool::SpawnAgent, + status: V2CollabToolCallStatus::InProgress, + sender_thread_id: begin_event.sender_thread_id.to_string(), + receiver_thread_id: None, + prompt: Some(begin_event.prompt), + agent_state: None, + }; + let notification = ItemStartedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemStarted(notification)) + .await; + } + EventMsg::CollabAgentSpawnEnd(end_event) => { + let status = if end_event.new_thread_id.is_some() { + V2CollabToolCallStatus::Completed + } else { + V2CollabToolCallStatus::Failed + }; + let item = ThreadItem::CollabAgentToolCall { + id: end_event.call_id, + tool: CollabAgentTool::SpawnAgent, + status, + sender_thread_id: end_event.sender_thread_id.to_string(), + receiver_thread_id: end_event.new_thread_id.map(|id| id.to_string()), + prompt: Some(end_event.prompt), + agent_state: Some(V2CollabAgentStatus::from(end_event.status)), + }; + let notification = ItemCompletedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemCompleted(notification)) + .await; + } + EventMsg::CollabAgentInteractionBegin(begin_event) => { + let item = ThreadItem::CollabAgentToolCall { + id: begin_event.call_id, + tool: CollabAgentTool::SendInput, + status: V2CollabToolCallStatus::InProgress, + sender_thread_id: begin_event.sender_thread_id.to_string(), + receiver_thread_id: Some(begin_event.receiver_thread_id.to_string()), + prompt: Some(begin_event.prompt), + agent_state: None, + }; + let notification = ItemStartedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemStarted(notification)) + .await; + } + EventMsg::CollabAgentInteractionEnd(end_event) => { + let status = match end_event.status { + codex_protocol::protocol::AgentStatus::Errored(_) + | codex_protocol::protocol::AgentStatus::NotFound => V2CollabToolCallStatus::Failed, + _ => V2CollabToolCallStatus::Completed, + }; + let item = ThreadItem::CollabAgentToolCall { + id: end_event.call_id, + tool: CollabAgentTool::SendInput, + status, + sender_thread_id: end_event.sender_thread_id.to_string(), + receiver_thread_id: Some(end_event.receiver_thread_id.to_string()), + prompt: Some(end_event.prompt), + agent_state: Some(V2CollabAgentStatus::from(end_event.status)), + }; + let notification = ItemCompletedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemCompleted(notification)) + .await; + } + EventMsg::CollabWaitingBegin(begin_event) => { + let item = ThreadItem::CollabAgentToolCall { + id: begin_event.call_id, + tool: CollabAgentTool::Wait, + status: V2CollabToolCallStatus::InProgress, + sender_thread_id: begin_event.sender_thread_id.to_string(), + receiver_thread_id: Some(begin_event.receiver_thread_id.to_string()), + prompt: None, + agent_state: None, + }; + let notification = ItemStartedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemStarted(notification)) + .await; + } + EventMsg::CollabWaitingEnd(end_event) => { + let status = match end_event.status { + codex_protocol::protocol::AgentStatus::Errored(_) + | codex_protocol::protocol::AgentStatus::NotFound => V2CollabToolCallStatus::Failed, + _ => V2CollabToolCallStatus::Completed, + }; + let item = ThreadItem::CollabAgentToolCall { + id: end_event.call_id, + tool: CollabAgentTool::Wait, + status, + sender_thread_id: end_event.sender_thread_id.to_string(), + receiver_thread_id: Some(end_event.receiver_thread_id.to_string()), + prompt: None, + agent_state: Some(V2CollabAgentStatus::from(end_event.status)), + }; + let notification = ItemCompletedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemCompleted(notification)) + .await; + } + EventMsg::CollabCloseBegin(begin_event) => { + let item = ThreadItem::CollabAgentToolCall { + id: begin_event.call_id, + tool: CollabAgentTool::CloseAgent, + status: V2CollabToolCallStatus::InProgress, + sender_thread_id: begin_event.sender_thread_id.to_string(), + receiver_thread_id: Some(begin_event.receiver_thread_id.to_string()), + prompt: None, + agent_state: None, + }; + let notification = ItemStartedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemStarted(notification)) + .await; + } + EventMsg::CollabCloseEnd(end_event) => { + let status = match end_event.status { + codex_protocol::protocol::AgentStatus::Errored(_) + | codex_protocol::protocol::AgentStatus::NotFound => V2CollabToolCallStatus::Failed, + _ => V2CollabToolCallStatus::Completed, + }; + let item = ThreadItem::CollabAgentToolCall { + id: end_event.call_id, + tool: CollabAgentTool::CloseAgent, + status, + sender_thread_id: end_event.sender_thread_id.to_string(), + receiver_thread_id: Some(end_event.receiver_thread_id.to_string()), + prompt: None, + agent_state: Some(V2CollabAgentStatus::from(end_event.status)), + }; + let notification = ItemCompletedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item, + }; + outgoing + .send_server_notification(ServerNotification::ItemCompleted(notification)) + .await; + } EventMsg::AgentMessageContentDelta(event) => { let notification = AgentMessageDeltaNotification { thread_id: conversation_id.to_string(), diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index 0a64ed7191..fc7115447d 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -3125,10 +3125,12 @@ impl CodexMessageProcessor { let mapped_items: Vec = items .into_iter() .map(|item| match item { - WireInputItem::Text { text } => CoreInputItem::Text { + WireInputItem::Text { text, - // TODO: Thread text element ranges into v1 input handling. - text_elements: Vec::new(), + text_elements, + } => CoreInputItem::Text { + text, + text_elements: text_elements.into_iter().map(Into::into).collect(), }, WireInputItem::Image { image_url } => CoreInputItem::Image { image_url }, WireInputItem::LocalImage { path } => CoreInputItem::LocalImage { path }, @@ -3175,10 +3177,12 @@ impl CodexMessageProcessor { let mapped_items: Vec = items .into_iter() .map(|item| match item { - WireInputItem::Text { text } => CoreInputItem::Text { + WireInputItem::Text { text, - // TODO: Thread text element ranges into v1 input handling. - text_elements: Vec::new(), + text_elements, + } => CoreInputItem::Text { + text, + text_elements: text_elements.into_iter().map(Into::into).collect(), }, WireInputItem::Image { image_url } => CoreInputItem::Image { image_url }, WireInputItem::LocalImage { path } => CoreInputItem::LocalImage { path }, @@ -3341,6 +3345,7 @@ impl CodexMessageProcessor { id: turn_id.clone(), content: vec![V2UserInput::Text { text: display_text.to_string(), + // Review prompt display text is synthesized; no UI element ranges to preserve. text_elements: Vec::new(), }], }] @@ -3894,6 +3899,16 @@ fn skills_to_info( name: skill.name.clone(), description: skill.description.clone(), short_description: skill.short_description.clone(), + interface: skill.interface.clone().map(|interface| { + codex_app_server_protocol::SkillInterface { + display_name: interface.display_name, + short_description: interface.short_description, + icon_small: interface.icon_small, + icon_large: interface.icon_large, + brand_color: interface.brand_color, + default_prompt: interface.default_prompt, + } + }), path: skill.path.clone(), scope: skill.scope.into(), }) diff --git a/codex-rs/app-server/tests/common/lib.rs b/codex-rs/app-server/tests/common/lib.rs index af4982b846..48577db110 100644 --- a/codex-rs/app-server/tests/common/lib.rs +++ b/codex-rs/app-server/tests/common/lib.rs @@ -29,6 +29,7 @@ pub use responses::create_exec_command_sse_response; pub use responses::create_final_assistant_message_sse_response; pub use responses::create_shell_command_sse_response; pub use rollout::create_fake_rollout; +pub use rollout::create_fake_rollout_with_text_elements; use serde::de::DeserializeOwned; pub fn to_response(response: JSONRPCResponse) -> anyhow::Result { diff --git a/codex-rs/app-server/tests/common/rollout.rs b/codex-rs/app-server/tests/common/rollout.rs index b5829716af..784b79b98d 100644 --- a/codex-rs/app-server/tests/common/rollout.rs +++ b/codex-rs/app-server/tests/common/rollout.rs @@ -87,3 +87,75 @@ pub fn create_fake_rollout( fs::write(file_path, lines.join("\n") + "\n")?; Ok(uuid_str) } + +pub fn create_fake_rollout_with_text_elements( + codex_home: &Path, + filename_ts: &str, + meta_rfc3339: &str, + preview: &str, + text_elements: Vec, + model_provider: Option<&str>, + git_info: Option, +) -> Result { + let uuid = Uuid::new_v4(); + let uuid_str = uuid.to_string(); + let conversation_id = ThreadId::from_string(&uuid_str)?; + + // sessions/YYYY/MM/DD derived from filename_ts (YYYY-MM-DDThh-mm-ss) + let year = &filename_ts[0..4]; + let month = &filename_ts[5..7]; + let day = &filename_ts[8..10]; + let dir = codex_home.join("sessions").join(year).join(month).join(day); + fs::create_dir_all(&dir)?; + + let file_path = dir.join(format!("rollout-{filename_ts}-{uuid}.jsonl")); + + // Build JSONL lines + let meta = SessionMeta { + id: conversation_id, + timestamp: meta_rfc3339.to_string(), + cwd: PathBuf::from("/"), + originator: "codex".to_string(), + cli_version: "0.0.0".to_string(), + instructions: None, + source: SessionSource::Cli, + model_provider: model_provider.map(str::to_string), + }; + let payload = serde_json::to_value(SessionMetaLine { + meta, + git: git_info, + })?; + + let lines = [ + json!( { + "timestamp": meta_rfc3339, + "type": "session_meta", + "payload": payload + }) + .to_string(), + json!( { + "timestamp": meta_rfc3339, + "type":"response_item", + "payload": { + "type":"message", + "role":"user", + "content":[{"type":"input_text","text": preview}] + } + }) + .to_string(), + json!( { + "timestamp": meta_rfc3339, + "type":"event_msg", + "payload": { + "type":"user_message", + "message": preview, + "text_elements": text_elements, + "local_images": [] + } + }) + .to_string(), + ]; + + fs::write(file_path, lines.join("\n") + "\n")?; + Ok(uuid_str) +} diff --git a/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs b/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs index 456206af89..b97acfc40c 100644 --- a/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs +++ b/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs @@ -114,6 +114,7 @@ async fn test_codex_jsonrpc_conversation_flow() -> Result<()> { conversation_id, items: vec![codex_app_server_protocol::InputItem::Text { text: "text".to_string(), + text_elements: Vec::new(), }], }) .await?; @@ -241,6 +242,7 @@ async fn test_send_user_turn_changes_approval_policy_behavior() -> Result<()> { conversation_id, items: vec![codex_app_server_protocol::InputItem::Text { text: "run python".to_string(), + text_elements: Vec::new(), }], }) .await?; @@ -296,6 +298,7 @@ async fn test_send_user_turn_changes_approval_policy_behavior() -> Result<()> { conversation_id, items: vec![codex_app_server_protocol::InputItem::Text { text: "run python again".to_string(), + text_elements: Vec::new(), }], cwd: working_directory.clone(), approval_policy: AskForApproval::Never, @@ -405,6 +408,7 @@ async fn test_send_user_turn_updates_sandbox_and_cwd_between_turns() -> Result<( conversation_id, items: vec![InputItem::Text { text: "first turn".to_string(), + text_elements: Vec::new(), }], cwd: first_cwd.clone(), approval_policy: AskForApproval::Never, @@ -437,6 +441,7 @@ async fn test_send_user_turn_updates_sandbox_and_cwd_between_turns() -> Result<( conversation_id, items: vec![InputItem::Text { text: "second turn".to_string(), + text_elements: Vec::new(), }], cwd: second_cwd.clone(), approval_policy: AskForApproval::Never, diff --git a/codex-rs/app-server/tests/suite/create_thread.rs b/codex-rs/app-server/tests/suite/create_thread.rs index 9709af03bf..8ad3342539 100644 --- a/codex-rs/app-server/tests/suite/create_thread.rs +++ b/codex-rs/app-server/tests/suite/create_thread.rs @@ -77,6 +77,7 @@ async fn test_conversation_create_and_send_message_ok() -> Result<()> { conversation_id, items: vec![InputItem::Text { text: "Hello".to_string(), + text_elements: Vec::new(), }], }) .await?; diff --git a/codex-rs/app-server/tests/suite/interrupt.rs b/codex-rs/app-server/tests/suite/interrupt.rs index 6248581e28..f8dc2a7e8e 100644 --- a/codex-rs/app-server/tests/suite/interrupt.rs +++ b/codex-rs/app-server/tests/suite/interrupt.rs @@ -105,6 +105,7 @@ async fn shell_command_interruption() -> anyhow::Result<()> { conversation_id, items: vec![codex_app_server_protocol::InputItem::Text { text: "run first sleep command".to_string(), + text_elements: Vec::new(), }], }) .await?; diff --git a/codex-rs/app-server/tests/suite/output_schema.rs b/codex-rs/app-server/tests/suite/output_schema.rs index 4ec500a245..c120a7fe2d 100644 --- a/codex-rs/app-server/tests/suite/output_schema.rs +++ b/codex-rs/app-server/tests/suite/output_schema.rs @@ -80,6 +80,7 @@ async fn send_user_turn_accepts_output_schema_v1() -> Result<()> { conversation_id, items: vec![InputItem::Text { text: "Hello".to_string(), + text_elements: Vec::new(), }], cwd: codex_home.path().to_path_buf(), approval_policy: AskForApproval::Never, @@ -181,6 +182,7 @@ async fn send_user_turn_output_schema_is_per_turn_v1() -> Result<()> { conversation_id, items: vec![InputItem::Text { text: "Hello".to_string(), + text_elements: Vec::new(), }], cwd: codex_home.path().to_path_buf(), approval_policy: AskForApproval::Never, @@ -228,6 +230,7 @@ async fn send_user_turn_output_schema_is_per_turn_v1() -> Result<()> { conversation_id, items: vec![InputItem::Text { text: "Hello again".to_string(), + text_elements: Vec::new(), }], cwd: codex_home.path().to_path_buf(), approval_policy: AskForApproval::Never, diff --git a/codex-rs/app-server/tests/suite/send_message.rs b/codex-rs/app-server/tests/suite/send_message.rs index 83e809f48e..0c713de87c 100644 --- a/codex-rs/app-server/tests/suite/send_message.rs +++ b/codex-rs/app-server/tests/suite/send_message.rs @@ -101,6 +101,7 @@ async fn send_message( conversation_id, items: vec![InputItem::Text { text: message.to_string(), + text_elements: Vec::new(), }], }) .await?; @@ -194,6 +195,7 @@ async fn test_send_message_raw_notifications_opt_in() -> Result<()> { conversation_id, items: vec![InputItem::Text { text: "Hello".to_string(), + text_elements: Vec::new(), }], }) .await?; @@ -245,6 +247,7 @@ async fn test_send_message_session_not_found() -> Result<()> { conversation_id: unknown, items: vec![InputItem::Text { text: "ping".to_string(), + text_elements: Vec::new(), }], }) .await?; @@ -425,7 +428,7 @@ fn content_texts(content: &[ContentItem]) -> Vec<&str> { content .iter() .filter_map(|item| match item { - ContentItem::InputText { text } | ContentItem::OutputText { text } => { + ContentItem::InputText { text, .. } | ContentItem::OutputText { text } => { Some(text.as_str()) } _ => None, diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rs index cfcfcedf70..be2971397d 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs @@ -1,6 +1,6 @@ use anyhow::Result; use app_test_support::McpProcess; -use app_test_support::create_fake_rollout; +use app_test_support::create_fake_rollout_with_text_elements; use app_test_support::create_mock_responses_server_repeating_assistant; use app_test_support::to_response; use codex_app_server_protocol::JSONRPCResponse; @@ -15,6 +15,9 @@ use codex_app_server_protocol::TurnStatus; use codex_app_server_protocol::UserInput; use codex_protocol::models::ContentItem; use codex_protocol::models::ResponseItem; +use codex_protocol::user_input::ByteRange; +use codex_protocol::user_input::TextElement; +use pretty_assertions::assert_eq; use std::path::PathBuf; use tempfile::TempDir; use tokio::time::timeout; @@ -71,11 +74,19 @@ async fn thread_resume_returns_rollout_history() -> Result<()> { create_config_toml(codex_home.path(), &server.uri())?; let preview = "Saved user message"; - let conversation_id = create_fake_rollout( + let text_elements = vec![TextElement { + byte_range: ByteRange { start: 0, end: 5 }, + placeholder: Some("".into()), + }]; + let conversation_id = create_fake_rollout_with_text_elements( codex_home.path(), "2025-01-05T12-00-00", "2025-01-05T12:00:00Z", preview, + text_elements + .iter() + .map(|elem| serde_json::to_value(elem).expect("serialize text element")) + .collect(), Some("mock_provider"), None, )?; @@ -119,7 +130,7 @@ async fn thread_resume_returns_rollout_history() -> Result<()> { content, &vec![UserInput::Text { text: preview.to_string(), - text_elements: Vec::new(), + text_elements: text_elements.clone().into_iter().map(Into::into).collect(), }] ); } diff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rs index 406f80328b..e3b758a4c6 100644 --- a/codex-rs/app-server/tests/suite/v2/turn_start.rs +++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs @@ -8,6 +8,7 @@ use app_test_support::create_mock_responses_server_sequence_unchecked; use app_test_support::create_shell_command_sse_response; use app_test_support::format_with_current_shell_display; use app_test_support::to_response; +use codex_app_server_protocol::ByteRange; use codex_app_server_protocol::ClientInfo; use codex_app_server_protocol::CommandExecutionApprovalDecision; use codex_app_server_protocol::CommandExecutionRequestApprovalResponse; @@ -23,6 +24,7 @@ use codex_app_server_protocol::PatchApplyStatus; use codex_app_server_protocol::PatchChangeKind; use codex_app_server_protocol::RequestId; use codex_app_server_protocol::ServerRequest; +use codex_app_server_protocol::TextElement; use codex_app_server_protocol::ThreadItem; use codex_app_server_protocol::ThreadStartParams; use codex_app_server_protocol::ThreadStartResponse; @@ -113,6 +115,87 @@ async fn turn_start_sends_originator_header() -> Result<()> { Ok(()) } +#[tokio::test] +async fn turn_start_emits_user_message_item_with_text_elements() -> Result<()> { + let responses = vec![create_final_assistant_message_sse_response("Done")?]; + let server = create_mock_responses_server_sequence_unchecked(responses).await; + + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri(), "never")?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let thread_req = mcp + .send_thread_start_request(ThreadStartParams { + model: Some("mock-model".to_string()), + ..Default::default() + }) + .await?; + let thread_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(thread_req)), + ) + .await??; + let ThreadStartResponse { thread, .. } = to_response::(thread_resp)?; + + let text_elements = vec![TextElement { + byte_range: ByteRange { start: 0, end: 5 }, + placeholder: Some("".to_string()), + }]; + let turn_req = mcp + .send_turn_start_request(TurnStartParams { + thread_id: thread.id.clone(), + input: vec![V2UserInput::Text { + text: "Hello".to_string(), + text_elements: text_elements.clone(), + }], + ..Default::default() + }) + .await?; + timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(turn_req)), + ) + .await??; + + let user_message_item = timeout(DEFAULT_READ_TIMEOUT, async { + loop { + let notification = mcp + .read_stream_until_notification_message("item/started") + .await?; + let params = notification.params.expect("item/started params"); + let item_started: ItemStartedNotification = + serde_json::from_value(params).expect("deserialize item/started notification"); + if let ThreadItem::UserMessage { .. } = item_started.item { + return Ok::(item_started.item); + } + } + }) + .await??; + + match user_message_item { + ThreadItem::UserMessage { content, .. } => { + assert_eq!( + content, + vec![V2UserInput::Text { + text: "Hello".to_string(), + text_elements, + }] + ); + } + other => panic!("expected user message item, got {other:?}"), + } + + timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_notification_message("turn/completed"), + ) + .await??; + + Ok(()) +} + #[tokio::test] async fn turn_start_emits_notifications_and_accepts_model_override() -> Result<()> { // Provide a mock server and config so model wiring is valid. diff --git a/codex-rs/cli/src/mcp_cmd.rs b/codex-rs/cli/src/mcp_cmd.rs index 30c6fa21f8..9035502af3 100644 --- a/codex-rs/cli/src/mcp_cmd.rs +++ b/codex-rs/cli/src/mcp_cmd.rs @@ -241,6 +241,7 @@ async fn run_add(config_overrides: &CliConfigOverrides, add_args: AddArgs) -> Re let new_entry = McpServerConfig { transport: transport.clone(), enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -448,6 +449,7 @@ async fn run_list(config_overrides: &CliConfigOverrides, list_args: ListArgs) -> serde_json::json!({ "name": name, "enabled": cfg.enabled, + "disabled_reason": cfg.disabled_reason.as_ref().map(ToString::to_string), "transport": transport, "startup_timeout_sec": cfg .startup_timeout_sec @@ -492,11 +494,7 @@ async fn run_list(config_overrides: &CliConfigOverrides, list_args: ListArgs) -> .map(|path| path.display().to_string()) .filter(|value| !value.is_empty()) .unwrap_or_else(|| "-".to_string()); - let status = if cfg.enabled { - "enabled".to_string() - } else { - "disabled".to_string() - }; + let status = format_mcp_status(cfg); let auth_status = auth_statuses .get(name.as_str()) .map(|entry| entry.auth_status) @@ -517,11 +515,7 @@ async fn run_list(config_overrides: &CliConfigOverrides, list_args: ListArgs) -> bearer_token_env_var, .. } => { - let status = if cfg.enabled { - "enabled".to_string() - } else { - "disabled".to_string() - }; + let status = format_mcp_status(cfg); let auth_status = auth_statuses .get(name.as_str()) .map(|entry| entry.auth_status) @@ -691,6 +685,7 @@ async fn run_get(config_overrides: &CliConfigOverrides, get_args: GetArgs) -> Re let output = serde_json::to_string_pretty(&serde_json::json!({ "name": get_args.name, "enabled": server.enabled, + "disabled_reason": server.disabled_reason.as_ref().map(ToString::to_string), "transport": transport, "enabled_tools": server.enabled_tools.clone(), "disabled_tools": server.disabled_tools.clone(), @@ -706,7 +701,11 @@ async fn run_get(config_overrides: &CliConfigOverrides, get_args: GetArgs) -> Re } if !server.enabled { - println!("{} (disabled)", get_args.name); + if let Some(reason) = server.disabled_reason.as_ref() { + println!("{name} (disabled: {reason})", name = get_args.name); + } else { + println!("{name} (disabled)", name = get_args.name); + } return Ok(()); } @@ -828,3 +827,13 @@ fn validate_server_name(name: &str) -> Result<()> { bail!("invalid server name '{name}' (use letters, numbers, '-', '_')"); } } + +fn format_mcp_status(config: &McpServerConfig) -> String { + if config.enabled { + "enabled".to_string() + } else if let Some(reason) = config.disabled_reason.as_ref() { + format!("disabled: {reason}") + } else { + "disabled".to_string() + } +} diff --git a/codex-rs/cli/tests/mcp_list.rs b/codex-rs/cli/tests/mcp_list.rs index 400f53365e..cb78644b1b 100644 --- a/codex-rs/cli/tests/mcp_list.rs +++ b/codex-rs/cli/tests/mcp_list.rs @@ -89,6 +89,7 @@ async fn list_and_get_render_expected_output() -> Result<()> { { "name": "docs", "enabled": true, + "disabled_reason": null, "transport": { "type": "stdio", "command": "docs-server", diff --git a/codex-rs/core/src/agent/control.rs b/codex-rs/core/src/agent/control.rs index c8ba7fdda1..7083081dc6 100644 --- a/codex-rs/core/src/agent/control.rs +++ b/codex-rs/core/src/agent/control.rs @@ -71,6 +71,12 @@ impl AgentControl { result } + /// Interrupt the current task for an existing agent thread. + pub(crate) async fn interrupt_agent(&self, agent_id: ThreadId) -> CodexResult { + let state = self.upgrade()?; + state.send_op(agent_id, Op::Interrupt).await + } + /// Submit a shutdown request to an existing agent thread. pub(crate) async fn shutdown_agent(&self, agent_id: ThreadId) -> CodexResult { let state = self.upgrade()?; diff --git a/codex-rs/core/src/agent/mod.rs b/codex-rs/core/src/agent/mod.rs index d6348b38b3..0387eda494 100644 --- a/codex-rs/core/src/agent/mod.rs +++ b/codex-rs/core/src/agent/mod.rs @@ -1,6 +1,8 @@ pub(crate) mod control; +pub(crate) mod role; pub(crate) mod status; pub(crate) use codex_protocol::protocol::AgentStatus; pub(crate) use control::AgentControl; +pub(crate) use role::AgentRole; pub(crate) use status::agent_status_from_event; diff --git a/codex-rs/core/src/agent/role.rs b/codex-rs/core/src/agent/role.rs new file mode 100644 index 0000000000..acb2481fc8 --- /dev/null +++ b/codex-rs/core/src/agent/role.rs @@ -0,0 +1,85 @@ +use crate::config::Config; +use crate::protocol::SandboxPolicy; +use serde::Deserialize; +use serde::Serialize; + +/// Base instructions for the orchestrator role. +const ORCHESTRATOR_PROMPT: &str = include_str!("../../templates/agents/orchestrator.md"); +/// Base instructions for the worker role. +const WORKER_PROMPT: &str = include_str!("../../gpt-5.2-codex_prompt.md"); +/// Default worker model override used by the worker role. +const WORKER_MODEL: &str = "gpt-5.2-codex"; + +/// Enumerated list of all supported agent roles. +const ALL_ROLES: [AgentRole; 3] = [ + AgentRole::Default, + AgentRole::Orchestrator, + AgentRole::Worker, +]; + +/// Hard-coded agent role selection used when spawning sub-agents. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AgentRole { + /// Inherit the parent agent's configuration unchanged. + Default, + /// Coordination-only agent that delegates to workers. + Orchestrator, + /// Task-executing agent with a fixed model override. + Worker, +} + +/// Immutable profile data that drives per-agent configuration overrides. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct AgentProfile { + /// Optional base instructions override. + pub base_instructions: Option<&'static str>, + /// Optional model override. + pub model: Option<&'static str>, + /// Whether to force a read-only sandbox policy. + pub read_only: bool, +} + +impl AgentRole { + /// Returns the string values used by JSON schema enums. + pub fn enum_values() -> Vec { + ALL_ROLES + .iter() + .filter_map(|role| serde_json::to_string(role).ok()) + .collect() + } + + /// Returns the hard-coded profile for this role. + pub fn profile(self) -> AgentProfile { + match self { + AgentRole::Default => AgentProfile::default(), + AgentRole::Orchestrator => AgentProfile { + base_instructions: Some(ORCHESTRATOR_PROMPT), + ..Default::default() + }, + AgentRole::Worker => AgentProfile { + base_instructions: Some(WORKER_PROMPT), + model: Some(WORKER_MODEL), + ..Default::default() + }, + } + } + + /// Applies this role's profile onto the provided config. + pub fn apply_to_config(self, config: &mut Config) -> Result<(), String> { + let profile = self.profile(); + if let Some(base_instructions) = profile.base_instructions { + config.base_instructions = Some(base_instructions.to_string()); + } + if let Some(model) = profile.model { + config.model = Some(model.to_string()); + } + if profile.read_only { + config + .sandbox_policy + .set(SandboxPolicy::new_read_only_policy()) + .map_err(|err| format!("sandbox_policy is invalid: {err}"))?; + } + Ok(()) + } +} diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index 438c7c5eee..326d81e0e9 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -31,6 +31,7 @@ use codex_otel::OtelManager; use codex_protocol::ThreadId; use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig; +use codex_protocol::config_types::WebSearchMode; use codex_protocol::models::ResponseItem; use codex_protocol::openai_models::ModelInfo; use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig; @@ -64,6 +65,8 @@ use crate::model_provider_info::WireApi; use crate::tools::spec::create_tools_json_for_chat_completions_api; use crate::tools::spec::create_tools_json_for_responses_api; +pub const WEB_SEARCH_ELIGIBLE_HEADER: &str = "x-oai-web-search-eligible"; + #[derive(Debug)] struct ModelClientState { config: Arc, @@ -319,7 +322,7 @@ impl ModelClientSession { store_override: None, conversation_id: Some(conversation_id), session_source: Some(self.state.session_source.clone()), - extra_headers: beta_feature_headers(&self.state.config), + extra_headers: build_responses_headers(&self.state.config), compression, } } @@ -635,6 +638,21 @@ fn beta_feature_headers(config: &Config) -> ApiHeaderMap { headers } +fn build_responses_headers(config: &Config) -> ApiHeaderMap { + let mut headers = beta_feature_headers(config); + headers.insert( + WEB_SEARCH_ELIGIBLE_HEADER, + HeaderValue::from_static( + if matches!(config.web_search_mode, Some(WebSearchMode::Disabled)) { + "false" + } else { + "true" + }, + ), + ); + headers +} + fn map_response_stream(api_stream: S, otel_manager: OtelManager) -> ResponseStream where S: futures::Stream> diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index c72d730a8b..46ac6e07d4 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -36,6 +36,7 @@ use codex_protocol::ThreadId; use codex_protocol::approvals::ExecPolicyAmendment; use codex_protocol::config_types::WebSearchMode; use codex_protocol::items::TurnItem; +use codex_protocol::items::UserMessageItem; use codex_protocol::openai_models::ModelInfo; use codex_protocol::protocol::FileChange; use codex_protocol::protocol::HasLegacyEvent; @@ -120,6 +121,7 @@ use crate::protocol::ReviewDecision; use crate::protocol::SandboxPolicy; use crate::protocol::SessionConfiguredEvent; use crate::protocol::SkillErrorInfo; +use crate::protocol::SkillInterface as ProtocolSkillInterface; use crate::protocol::SkillMetadata as ProtocolSkillMetadata; use crate::protocol::StreamErrorEvent; use crate::protocol::Submission; @@ -541,24 +543,12 @@ impl Session { web_search_mode: per_turn_config.web_search_mode, }); - let base_instructions = if per_turn_config.features.enabled(Feature::Collab) { - const COLLAB_INSTRUCTIONS: &str = - include_str!("../templates/collab/experimental_prompt.md"); - let base = session_configuration - .base_instructions - .as_deref() - .unwrap_or(model_info.base_instructions.as_str()); - Some(format!("{base}\n\n{COLLAB_INSTRUCTIONS}")) - } else { - session_configuration.base_instructions.clone() - }; - TurnContext { sub_id, client, cwd: session_configuration.cwd.clone(), developer_instructions: session_configuration.developer_instructions.clone(), - base_instructions, + base_instructions: session_configuration.base_instructions.clone(), compact_prompt: session_configuration.compact_prompt.clone(), user_instructions: session_configuration.user_instructions.clone(), approval_policy: session_configuration.approval_policy.value(), @@ -1536,6 +1526,22 @@ impl Session { } } + pub(crate) async fn record_user_prompt_and_emit_turn_item( + &self, + turn_context: &TurnContext, + input: &[UserInput], + response_item: ResponseItem, + ) { + // Persist the user message to history, but emit the turn item from `UserInput` so + // UI-only `text_elements` are preserved. `ResponseItem::Message` does not carry + // those spans, and `record_response_item_and_emit_turn_item` would drop them. + self.record_conversation_items(turn_context, std::slice::from_ref(&response_item)) + .await; + let turn_item = TurnItem::UserMessage(UserMessageItem::new(input)); + self.emit_turn_item_started(turn_context, &turn_item).await; + self.emit_turn_item_completed(turn_context, turn_item).await; + } + pub(crate) async fn notify_background_event( &self, turn_context: &TurnContext, @@ -2076,10 +2082,13 @@ mod handlers { codex_protocol::approvals::ElicitationAction::Decline => ElicitationAction::Decline, codex_protocol::approvals::ElicitationAction::Cancel => ElicitationAction::Cancel, }; - let response = ElicitationResponse { - action, - content: None, + // When accepting, send an empty object as content to satisfy MCP servers + // that expect non-null content on Accept. For Decline/Cancel, content is None. + let content = match action { + ElicitationAction::Accept => Some(serde_json::json!({})), + ElicitationAction::Decline | ElicitationAction::Cancel => None, }; + let response = ElicitationResponse { action, content }; if let Err(err) = sess .resolve_elicitation(server_name, request_id, response) .await @@ -2416,7 +2425,7 @@ async fn spawn_review_thread( let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &review_model_info, features: &review_features, - web_search_mode: review_web_search_mode, + web_search_mode: Some(review_web_search_mode), }); let base_instructions = REVIEW_PROMPT.to_string(); @@ -2429,7 +2438,7 @@ async fn spawn_review_thread( let mut per_turn_config = (*config).clone(); per_turn_config.model = Some(model.clone()); per_turn_config.features = review_features.clone(); - per_turn_config.web_search_mode = review_web_search_mode; + per_turn_config.web_search_mode = Some(review_web_search_mode); let otel_manager = parent_turn_context .client @@ -2492,6 +2501,17 @@ fn skills_to_info(skills: &[SkillMetadata]) -> Vec { name: skill.name.clone(), description: skill.description.clone(), short_description: skill.short_description.clone(), + interface: skill + .interface + .clone() + .map(|interface| ProtocolSkillInterface { + display_name: interface.display_name, + short_description: interface.short_description, + icon_small: interface.icon_small, + icon_large: interface.icon_large, + brand_color: interface.brand_color, + default_prompt: interface.default_prompt, + }), path: skill.path.clone(), scope: skill.scope, }) @@ -2560,9 +2580,9 @@ pub(crate) async fn run_turn( .await; } - let initial_input_for_turn: ResponseInputItem = ResponseInputItem::from(input); + let initial_input_for_turn: ResponseInputItem = ResponseInputItem::from(input.clone()); let response_item: ResponseItem = initial_input_for_turn.clone().into(); - sess.record_response_item_and_emit_turn_item(turn_context.as_ref(), response_item) + sess.record_user_prompt_and_emit_turn_item(turn_context.as_ref(), &input, response_item) .await; if !skill_items.is_empty() { @@ -2962,7 +2982,6 @@ async fn try_run_turn( should_emit_turn_diff = true; needs_follow_up |= sess.has_pending_input().await; - error!("needs_follow_up: {needs_follow_up}"); break Ok(TurnRunResult { needs_follow_up, diff --git a/codex-rs/core/src/config/edit.rs b/codex-rs/core/src/config/edit.rs index 0def0440a8..fb6829bb96 100644 --- a/codex-rs/core/src/config/edit.rs +++ b/codex-rs/core/src/config/edit.rs @@ -1124,6 +1124,7 @@ gpt-5 = "gpt-5.1" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: Some(vec!["one".to_string(), "two".to_string()]), @@ -1145,6 +1146,7 @@ gpt-5 = "gpt-5.1" env_http_headers: None, }, enabled: false, + disabled_reason: None, startup_timeout_sec: Some(std::time::Duration::from_secs(5)), tool_timeout_sec: None, enabled_tools: None, @@ -1209,6 +1211,7 @@ foo = { command = "cmd" } cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1252,6 +1255,7 @@ foo = { command = "cmd" } # keep me cwd: None, }, enabled: false, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1294,6 +1298,7 @@ foo = { command = "cmd", args = ["--flag"] } # keep me cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1337,6 +1342,7 @@ foo = { command = "cmd" } cwd: None, }, enabled: false, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs index 5e5d26c791..6228bc3ac3 100644 --- a/codex-rs/core/src/config/mod.rs +++ b/codex-rs/core/src/config/mod.rs @@ -2,6 +2,7 @@ use crate::auth::AuthCredentialsStoreMode; use crate::config::types::DEFAULT_OTEL_ENVIRONMENT; use crate::config::types::History; use crate::config::types::McpServerConfig; +use crate::config::types::McpServerDisabledReason; use crate::config::types::McpServerTransportConfig; use crate::config::types::Notice; use crate::config::types::Notifications; @@ -19,6 +20,7 @@ use crate::config_loader::ConfigRequirements; use crate::config_loader::LoaderOverrides; use crate::config_loader::McpServerIdentity; use crate::config_loader::McpServerRequirement; +use crate::config_loader::Sourced; use crate::config_loader::load_config_layers_state; use crate::features::Feature; use crate::features::FeatureOverrides; @@ -337,7 +339,8 @@ pub struct Config { /// model info's default preference. pub include_apply_patch_tool: bool, - pub web_search_mode: WebSearchMode, + /// Explicit or feature-derived web search mode. + pub web_search_mode: Option, /// If set to `true`, used only the experimental unified exec tool. pub use_experimental_unified_exec_tool: bool, @@ -539,25 +542,32 @@ fn deserialize_config_toml_with_base( fn filter_mcp_servers_by_requirements( mcp_servers: &mut HashMap, - mcp_requirements: Option<&BTreeMap>, + mcp_requirements: Option<&Sourced>>, ) { let Some(allowlist) = mcp_requirements else { return; }; + let source = allowlist.source.clone(); for (name, server) in mcp_servers.iter_mut() { let allowed = allowlist + .value .get(name) .is_some_and(|requirement| mcp_server_matches_requirement(requirement, server)); - if !allowed { + if allowed { + server.disabled_reason = None; + } else { server.enabled = false; + server.disabled_reason = Some(McpServerDisabledReason::Requirements { + source: source.clone(), + }); } } } fn constrain_mcp_servers( mcp_servers: HashMap, - mcp_requirements: Option<&BTreeMap>, + mcp_requirements: Option<&Sourced>>, ) -> ConstraintResult>> { if mcp_requirements.is_none() { return Ok(Constrained::allow_any(mcp_servers)); @@ -1182,24 +1192,22 @@ pub fn resolve_oss_provider( } } -/// Resolve the web search mode from the config, profile, and features. +/// Resolve the web search mode from explicit config and feature flags. fn resolve_web_search_mode( config_toml: &ConfigToml, config_profile: &ConfigProfile, features: &Features, -) -> WebSearchMode { - // Enum gets precedence over features flags +) -> Option { if let Some(mode) = config_profile.web_search.or(config_toml.web_search) { - return mode; + return Some(mode); } if features.enabled(Feature::WebSearchCached) { - return WebSearchMode::Cached; + return Some(WebSearchMode::Cached); } if features.enabled(Feature::WebSearchRequest) { - return WebSearchMode::Live; + return Some(WebSearchMode::Live); } - // Fall back to default - WebSearchMode::default() + None } impl Config { @@ -1707,6 +1715,7 @@ mod tests { use crate::config::types::HistoryPersistence; use crate::config::types::McpServerTransportConfig; use crate::config::types::Notifications; + use crate::config_loader::RequirementSource; use crate::features::Feature; use super::*; @@ -1728,6 +1737,7 @@ mod tests { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1744,6 +1754,7 @@ mod tests { env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1976,9 +1987,9 @@ trust_level = "trusted" (MATCHED_URL_SERVER.to_string(), http_mcp(GOOD_URL)), (DIFFERENT_NAME_SERVER.to_string(), stdio_mcp("same-cmd")), ]); - filter_mcp_servers_by_requirements( - &mut servers, - Some(&BTreeMap::from([ + let source = RequirementSource::LegacyManagedConfigTomlFromMdm; + let requirements = Sourced::new( + BTreeMap::from([ ( MISMATCHED_URL_SERVER.to_string(), McpServerRequirement { @@ -2011,20 +2022,29 @@ trust_level = "trusted" }, }, ), - ])), + ]), + source.clone(), ); + filter_mcp_servers_by_requirements(&mut servers, Some(&requirements)); + let reason = Some(McpServerDisabledReason::Requirements { source }); assert_eq!( servers .iter() - .map(|(name, server)| (name.clone(), server.enabled)) - .collect::>(), + .map(|(name, server)| ( + name.clone(), + (server.enabled, server.disabled_reason.clone()) + )) + .collect::)>>(), HashMap::from([ - (MISMATCHED_URL_SERVER.to_string(), false), - (MISMATCHED_COMMAND_SERVER.to_string(), false), - (MATCHED_URL_SERVER.to_string(), true), - (MATCHED_COMMAND_SERVER.to_string(), true), - (DIFFERENT_NAME_SERVER.to_string(), false), + (MISMATCHED_URL_SERVER.to_string(), (false, reason.clone())), + ( + MISMATCHED_COMMAND_SERVER.to_string(), + (false, reason.clone()), + ), + (MATCHED_URL_SERVER.to_string(), (true, None)), + (MATCHED_COMMAND_SERVER.to_string(), (true, None)), + (DIFFERENT_NAME_SERVER.to_string(), (false, reason)), ]) ); } @@ -2041,11 +2061,14 @@ trust_level = "trusted" assert_eq!( servers .iter() - .map(|(name, server)| (name.clone(), server.enabled)) - .collect::>(), + .map(|(name, server)| ( + name.clone(), + (server.enabled, server.disabled_reason.clone()) + )) + .collect::)>>(), HashMap::from([ - ("server-a".to_string(), true), - ("server-b".to_string(), true), + ("server-a".to_string(), (true, None)), + ("server-b".to_string(), (true, None)), ]) ); } @@ -2057,16 +2080,22 @@ trust_level = "trusted" ("server-b".to_string(), http_mcp("https://example.com/b")), ]); - filter_mcp_servers_by_requirements(&mut servers, Some(&BTreeMap::new())); + let source = RequirementSource::LegacyManagedConfigTomlFromMdm; + let requirements = Sourced::new(BTreeMap::new(), source.clone()); + filter_mcp_servers_by_requirements(&mut servers, Some(&requirements)); + let reason = Some(McpServerDisabledReason::Requirements { source }); assert_eq!( servers .iter() - .map(|(name, server)| (name.clone(), server.enabled)) - .collect::>(), + .map(|(name, server)| ( + name.clone(), + (server.enabled, server.disabled_reason.clone()) + )) + .collect::)>>(), HashMap::from([ - ("server-a".to_string(), false), - ("server-b".to_string(), false), + ("server-a".to_string(), (false, reason.clone())), + ("server-b".to_string(), (false, reason)), ]) ); } @@ -2202,15 +2231,12 @@ trust_level = "trusted" } #[test] - fn web_search_mode_uses_default_if_unset() { + fn web_search_mode_uses_none_if_unset() { let cfg = ConfigToml::default(); let profile = ConfigProfile::default(); let features = Features::with_defaults(); - assert_eq!( - resolve_web_search_mode(&cfg, &profile, &features), - WebSearchMode::default() - ); + assert_eq!(resolve_web_search_mode(&cfg, &profile, &features), None); } #[test] @@ -2225,7 +2251,7 @@ trust_level = "trusted" assert_eq!( resolve_web_search_mode(&cfg, &profile, &features), - WebSearchMode::Live + Some(WebSearchMode::Live) ); } @@ -2241,7 +2267,7 @@ trust_level = "trusted" assert_eq!( resolve_web_search_mode(&cfg, &profile, &features), - WebSearchMode::Disabled + Some(WebSearchMode::Disabled) ); } @@ -2491,6 +2517,7 @@ trust_level = "trusted" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(3)), tool_timeout_sec: Some(Duration::from_secs(5)), enabled_tools: None, @@ -2644,6 +2671,7 @@ bearer_token = "secret" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -2712,6 +2740,7 @@ ZIG_VAR = "3" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -2760,6 +2789,7 @@ ZIG_VAR = "3" cwd: Some(cwd_path.clone()), }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -2806,6 +2836,7 @@ ZIG_VAR = "3" env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(2)), tool_timeout_sec: None, enabled_tools: None, @@ -2868,6 +2899,7 @@ startup_timeout_sec = 2.0 )])), }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(2)), tool_timeout_sec: None, enabled_tools: None, @@ -2942,6 +2974,7 @@ X-Auth = "DOCS_AUTH" )])), }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(2)), tool_timeout_sec: None, enabled_tools: None, @@ -2969,6 +3002,7 @@ X-Auth = "DOCS_AUTH" env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -3034,6 +3068,7 @@ url = "https://example.com/mcp" )])), }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(2)), tool_timeout_sec: None, enabled_tools: None, @@ -3051,6 +3086,7 @@ url = "https://example.com/mcp" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -3131,6 +3167,7 @@ url = "https://example.com/mcp" cwd: None, }, enabled: false, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -3173,6 +3210,7 @@ url = "https://example.com/mcp" cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: Some(vec!["allowed".to_string()]), @@ -3581,7 +3619,7 @@ model_verbosity = "high" forced_chatgpt_workspace_id: None, forced_login_method: None, include_apply_patch_tool: false, - web_search_mode: WebSearchMode::default(), + web_search_mode: None, use_experimental_unified_exec_tool: false, ghost_snapshot: GhostSnapshotConfig::default(), features: Features::with_defaults(), @@ -3668,7 +3706,7 @@ model_verbosity = "high" forced_chatgpt_workspace_id: None, forced_login_method: None, include_apply_patch_tool: false, - web_search_mode: WebSearchMode::default(), + web_search_mode: None, use_experimental_unified_exec_tool: false, ghost_snapshot: GhostSnapshotConfig::default(), features: Features::with_defaults(), @@ -3770,7 +3808,7 @@ model_verbosity = "high" forced_chatgpt_workspace_id: None, forced_login_method: None, include_apply_patch_tool: false, - web_search_mode: WebSearchMode::default(), + web_search_mode: None, use_experimental_unified_exec_tool: false, ghost_snapshot: GhostSnapshotConfig::default(), features: Features::with_defaults(), @@ -3858,7 +3896,7 @@ model_verbosity = "high" forced_chatgpt_workspace_id: None, forced_login_method: None, include_apply_patch_tool: false, - web_search_mode: WebSearchMode::default(), + web_search_mode: None, use_experimental_unified_exec_tool: false, ghost_snapshot: GhostSnapshotConfig::default(), features: Features::with_defaults(), diff --git a/codex-rs/core/src/config/types.rs b/codex-rs/core/src/config/types.rs index 13b201e84e..981f9b541a 100644 --- a/codex-rs/core/src/config/types.rs +++ b/codex-rs/core/src/config/types.rs @@ -3,11 +3,13 @@ // Note this file should generally be restricted to simple struct/enum // definitions that do not contain business logic. +use crate::config_loader::RequirementSource; pub use codex_protocol::config_types::AltScreenMode; pub use codex_protocol::config_types::WebSearchMode; use codex_utils_absolute_path::AbsolutePathBuf; use std::collections::BTreeMap; use std::collections::HashMap; +use std::fmt; use std::path::PathBuf; use std::time::Duration; use wildmatch::WildMatchPattern; @@ -20,6 +22,23 @@ use serde::de::Error as SerdeError; pub const DEFAULT_OTEL_ENVIRONMENT: &str = "dev"; +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum McpServerDisabledReason { + Unknown, + Requirements { source: RequirementSource }, +} + +impl fmt::Display for McpServerDisabledReason { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + McpServerDisabledReason::Unknown => write!(f, "unknown"), + McpServerDisabledReason::Requirements { source } => { + write!(f, "requirements ({source})") + } + } + } +} + #[derive(Serialize, Debug, Clone, PartialEq)] pub struct McpServerConfig { #[serde(flatten)] @@ -29,6 +48,10 @@ pub struct McpServerConfig { #[serde(default = "default_enabled")] pub enabled: bool, + /// Reason this server was disabled after applying requirements. + #[serde(skip)] + pub disabled_reason: Option, + /// Startup timeout in seconds for initializing MCP server & initially listing tools. #[serde( default, @@ -160,6 +183,7 @@ impl<'de> Deserialize<'de> for McpServerConfig { startup_timeout_sec, tool_timeout_sec, enabled, + disabled_reason: None, enabled_tools, disabled_tools, }) diff --git a/codex-rs/core/src/config_loader/config_requirements.rs b/codex-rs/core/src/config_loader/config_requirements.rs index 0411b0916b..a83398c711 100644 --- a/codex-rs/core/src/config_loader/config_requirements.rs +++ b/codex-rs/core/src/config_loader/config_requirements.rs @@ -44,7 +44,7 @@ impl fmt::Display for RequirementSource { pub struct ConfigRequirements { pub approval_policy: Constrained, pub sandbox_policy: Constrained, - pub mcp_servers: Option>, + pub mcp_servers: Option>>, } impl Default for ConfigRequirements { @@ -273,7 +273,7 @@ impl TryFrom for ConfigRequirements { Ok(ConfigRequirements { approval_policy, sandbox_policy, - mcp_servers: mcp_servers.map(|sourced| sourced.value), + mcp_servers, }) } } @@ -571,24 +571,27 @@ mod tests { assert_eq!( requirements.mcp_servers, - Some(BTreeMap::from([ - ( - "docs".to_string(), - McpServerRequirement { - identity: McpServerIdentity::Command { - command: "codex-mcp".to_string(), + Some(Sourced::new( + BTreeMap::from([ + ( + "docs".to_string(), + McpServerRequirement { + identity: McpServerIdentity::Command { + command: "codex-mcp".to_string(), + }, }, - }, - ), - ( - "remote".to_string(), - McpServerRequirement { - identity: McpServerIdentity::Url { - url: "https://example.com/mcp".to_string(), + ), + ( + "remote".to_string(), + McpServerRequirement { + identity: McpServerIdentity::Url { + url: "https://example.com/mcp".to_string(), + }, }, - }, - ), - ])) + ), + ]), + RequirementSource::Unknown, + )) ); Ok(()) } diff --git a/codex-rs/core/src/config_loader/mod.rs b/codex-rs/core/src/config_loader/mod.rs index 7e6d4223ca..9a8791eeef 100644 --- a/codex-rs/core/src/config_loader/mod.rs +++ b/codex-rs/core/src/config_loader/mod.rs @@ -30,6 +30,7 @@ pub use config_requirements::McpServerIdentity; pub use config_requirements::McpServerRequirement; pub use config_requirements::RequirementSource; pub use config_requirements::SandboxModeRequirement; +pub use config_requirements::Sourced; pub use merge::merge_toml_values; pub(crate) use overrides::build_cli_overrides_layer; pub use state::ConfigLayerEntry; diff --git a/codex-rs/core/src/features.rs b/codex-rs/core/src/features.rs index 620e777f4e..2ea63f812a 100644 --- a/codex-rs/core/src/features.rs +++ b/codex-rs/core/src/features.rs @@ -403,7 +403,17 @@ pub const FEATURES: &[FeatureSpec] = &[ FeatureSpec { id: Feature::PowershellUtf8, key: "powershell_utf8", + #[cfg(windows)] + stage: Stage::Beta { + name: "Powershell UTF-8 support", + menu_description: "Enable UTF-8 output in Powershell.", + announcement: "Codex now supports UTF-8 output in Powershell. If you are seeing problems, disable in /experimental.", + }, + #[cfg(windows)] + default_enabled: true, + #[cfg(not(windows))] stage: Stage::Experimental, + #[cfg(not(windows))] default_enabled: false, }, FeatureSpec { diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs index 4c6183454d..498c45748f 100644 --- a/codex-rs/core/src/lib.rs +++ b/codex-rs/core/src/lib.rs @@ -111,6 +111,7 @@ mod user_shell_command; pub mod util; pub use apply_patch::CODEX_APPLY_PATCH_ARG1; +pub use client::WEB_SEARCH_ELIGIBLE_HEADER; pub use command_safety::is_dangerous_command; pub use command_safety::is_safe_command; pub use exec_policy::ExecPolicyError; diff --git a/codex-rs/core/src/mcp_connection_manager.rs b/codex-rs/core/src/mcp_connection_manager.rs index 6574437bd0..0d638760f5 100644 --- a/codex-rs/core/src/mcp_connection_manager.rs +++ b/codex-rs/core/src/mcp_connection_manager.rs @@ -1171,6 +1171,7 @@ mod tests { env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1215,6 +1216,7 @@ mod tests { env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/core/src/rollout/recorder.rs b/codex-rs/core/src/rollout/recorder.rs index dfafb29115..7151f95b95 100644 --- a/codex-rs/core/src/rollout/recorder.rs +++ b/codex-rs/core/src/rollout/recorder.rs @@ -28,6 +28,7 @@ use super::policy::is_persisted_response_item; use crate::config::Config; use crate::default_client::originator; use crate::git_info::collect_git_info; +use crate::path_utils; use codex_protocol::protocol::InitialHistory; use codex_protocol::protocol::ResumedHistory; use codex_protocol::protocol::RolloutItem; @@ -113,6 +114,35 @@ impl RolloutRecorder { .await } + /// Find the newest recorded thread path, optionally filtering to a matching cwd. + pub async fn find_latest_thread_path( + codex_home: &Path, + allowed_sources: &[SessionSource], + model_providers: Option<&[String]>, + default_provider: &str, + filter_cwd: Option<&Path>, + ) -> std::io::Result> { + let mut cursor: Option = None; + loop { + let page = Self::list_threads( + codex_home, + 25, + cursor.as_ref(), + allowed_sources, + model_providers, + default_provider, + ) + .await?; + if let Some(path) = select_resume_path(&page, filter_cwd) { + return Ok(Some(path)); + } + cursor = page.next_cursor; + if cursor.is_none() { + return Ok(None); + } + } + } + /// Attempt to create a new [`RolloutRecorder`]. If the sessions directory /// cannot be created or the rollout file cannot be opened we return the /// error so the caller can decide whether to disable persistence. @@ -431,3 +461,36 @@ impl JsonlWriter { Ok(()) } } + +fn select_resume_path(page: &ThreadsPage, filter_cwd: Option<&Path>) -> Option { + match filter_cwd { + Some(cwd) => page.items.iter().find_map(|item| { + if session_cwd_matches(&item.head, cwd) { + Some(item.path.clone()) + } else { + None + } + }), + None => page.items.first().map(|item| item.path.clone()), + } +} + +fn session_cwd_matches(head: &[serde_json::Value], cwd: &Path) -> bool { + let Some(session_cwd) = extract_session_cwd(head) else { + return false; + }; + if let (Ok(ca), Ok(cb)) = ( + path_utils::normalize_for_path_comparison(&session_cwd), + path_utils::normalize_for_path_comparison(cwd), + ) { + return ca == cb; + } + session_cwd == cwd +} + +fn extract_session_cwd(head: &[serde_json::Value]) -> Option { + head.iter().find_map(|value| { + let meta_line = serde_json::from_value::(value.clone()).ok()?; + Some(meta_line.meta.cwd) + }) +} diff --git a/codex-rs/core/src/skills/loader.rs b/codex-rs/core/src/skills/loader.rs index a7461dcf97..da51fea41e 100644 --- a/codex-rs/core/src/skills/loader.rs +++ b/codex-rs/core/src/skills/loader.rs @@ -1,6 +1,7 @@ use crate::config::Config; use crate::config_loader::ConfigLayerStack; use crate::skills::model::SkillError; +use crate::skills::model::SkillInterface; use crate::skills::model::SkillLoadOutcome; use crate::skills::model::SkillMetadata; use crate::skills::system::system_cache_root_dir; @@ -13,6 +14,7 @@ use std::collections::VecDeque; use std::error::Error; use std::fmt; use std::fs; +use std::path::Component; use std::path::Path; use std::path::PathBuf; use tracing::error; @@ -31,11 +33,29 @@ struct SkillFrontmatterMetadata { short_description: Option, } +#[derive(Debug, Default, Deserialize)] +struct SkillToml { + #[serde(default)] + interface: Option, +} + +#[derive(Debug, Default, Deserialize)] +struct Interface { + display_name: Option, + short_description: Option, + icon_small: Option, + icon_large: Option, + brand_color: Option, + default_prompt: Option, +} + const SKILLS_FILENAME: &str = "SKILL.md"; +const SKILLS_TOML_FILENAME: &str = "SKILL.toml"; const SKILLS_DIR_NAME: &str = "skills"; const MAX_NAME_LEN: usize = 64; const MAX_DESCRIPTION_LEN: usize = 1024; const MAX_SHORT_DESCRIPTION_LEN: usize = MAX_DESCRIPTION_LEN; +const MAX_DEFAULT_PROMPT_LEN: usize = MAX_DESCRIPTION_LEN; // Traversal depth from the skills root. const MAX_SCAN_DEPTH: usize = 6; const MAX_SKILLS_DIRS_PER_ROOT: usize = 2000; @@ -195,7 +215,7 @@ fn discover_skills_under_root(root: &Path, scope: SkillScope, outcome: &mut Skil } } - // Follow symlinks for user, admin, and repo skills. System skills are written by Codex itself. + // Follow symlinked directories for user, admin, and repo skills. System skills are written by Codex itself. let follow_symlinks = matches!( scope, SkillScope::Repo | SkillScope::User | SkillScope::Admin @@ -262,20 +282,6 @@ fn discover_skills_under_root(root: &Path, scope: SkillScope, outcome: &mut Skil continue; } - if metadata.is_file() && file_name == SKILLS_FILENAME { - match parse_skill_file(&path, scope) { - Ok(skill) => outcome.skills.push(skill), - Err(err) => { - if scope != SkillScope::System { - outcome.errors.push(SkillError { - path, - message: err.to_string(), - }); - } - } - } - } - continue; } @@ -336,11 +342,12 @@ fn parse_skill_file(path: &Path, scope: SkillScope) -> Result Result Option { + // Fail open: optional SKILL.toml metadata should not block loading SKILL.md. + let skill_dir = skill_path.parent()?; + let interface_path = skill_dir.join(SKILLS_TOML_FILENAME); + if !interface_path.exists() { + return None; + } + + let contents = match fs::read_to_string(&interface_path) { + Ok(contents) => contents, + Err(error) => { + tracing::warn!( + "ignoring {path}: failed to read SKILL.toml: {error}", + path = interface_path.display() + ); + return None; + } + }; + let parsed: SkillToml = match toml::from_str(&contents) { + Ok(parsed) => parsed, + Err(error) => { + tracing::warn!( + "ignoring {path}: invalid TOML: {error}", + path = interface_path.display() + ); + return None; + } + }; + let interface = parsed.interface?; + + let interface = SkillInterface { + display_name: resolve_str( + interface.display_name, + MAX_NAME_LEN, + "interface.display_name", + ), + short_description: resolve_str( + interface.short_description, + MAX_SHORT_DESCRIPTION_LEN, + "interface.short_description", + ), + icon_small: resolve_asset_path(skill_dir, "interface.icon_small", interface.icon_small), + icon_large: resolve_asset_path(skill_dir, "interface.icon_large", interface.icon_large), + brand_color: resolve_color_str(interface.brand_color, "interface.brand_color"), + default_prompt: resolve_str( + interface.default_prompt, + MAX_DEFAULT_PROMPT_LEN, + "interface.default_prompt", + ), + }; + let has_fields = interface.display_name.is_some() + || interface.short_description.is_some() + || interface.icon_small.is_some() + || interface.icon_large.is_some() + || interface.brand_color.is_some() + || interface.default_prompt.is_some(); + if has_fields { Some(interface) } else { None } +} + +fn resolve_asset_path( + skill_dir: &Path, + field: &'static str, + path: Option, +) -> Option { + // Icons must be relative paths under the skill's assets/ directory; otherwise return None. + let path = path?; + if path.as_os_str().is_empty() { + return None; + } + + let assets_dir = skill_dir.join("assets"); + if path.is_absolute() { + tracing::warn!( + "ignoring {field}: icon must be a relative assets path (not {})", + assets_dir.display() + ); + return None; + } + + let mut components = path.components().peekable(); + while matches!(components.peek(), Some(Component::CurDir)) { + components.next(); + } + match components.next() { + Some(Component::Normal(component)) if component == "assets" => {} + _ => { + tracing::warn!("ignoring {field}: icon path must be under assets/"); + return None; + } + } + if components.any(|component| matches!(component, Component::ParentDir)) { + tracing::warn!("ignoring {field}: icon path must not contain '..'"); + return None; + } + + Some(skill_dir.join(path)) +} + fn sanitize_single_line(raw: &str) -> String { raw.split_whitespace().collect::>().join(" ") } -fn validate_field( +fn validate_len( value: &str, max_len: usize, field_name: &'static str, @@ -379,6 +485,36 @@ fn validate_field( Ok(()) } +fn resolve_str(value: Option, max_len: usize, field: &'static str) -> Option { + let value = value?; + let value = sanitize_single_line(&value); + if value.is_empty() { + tracing::warn!("ignoring {field}: value is empty"); + return None; + } + if value.chars().count() > max_len { + tracing::warn!("ignoring {field}: exceeds maximum length of {max_len} characters"); + return None; + } + Some(value) +} + +fn resolve_color_str(value: Option, field: &'static str) -> Option { + let value = value?; + let value = value.trim(); + if value.is_empty() { + tracing::warn!("ignoring {field}: value is empty"); + return None; + } + let mut chars = value.chars(); + if value.len() == 7 && chars.next() == Some('#') && chars.all(|c| c.is_ascii_hexdigit()) { + Some(value.to_string()) + } else { + tracing::warn!("ignoring {field}: expected #RRGGBB, got {value}"); + None + } +} + fn extract_frontmatter(contents: &str) -> Option { let mut lines = contents.lines(); if !matches!(lines.next(), Some(line) if line.trim() == "---") { @@ -528,6 +664,224 @@ mod tests { path } + fn write_skill_interface_at(skill_dir: &Path, contents: &str) -> PathBuf { + let path = skill_dir.join(SKILLS_TOML_FILENAME); + fs::write(&path, contents).unwrap(); + path + } + + #[tokio::test] + async fn loads_skill_interface_metadata_happy_path() { + let codex_home = tempfile::tempdir().expect("tempdir"); + let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from toml"); + let skill_dir = skill_path.parent().expect("skill dir"); + let normalized_skill_dir = normalized(skill_dir); + + write_skill_interface_at( + skill_dir, + r##" +[interface] +display_name = "UI Skill" +short_description = " short desc " +icon_small = "./assets/small-400px.png" +icon_large = "./assets/large-logo.svg" +brand_color = "#3B82F6" +default_prompt = " default prompt " +"##, + ); + + let cfg = make_config(&codex_home).await; + let outcome = load_skills(&cfg); + + assert!( + outcome.errors.is_empty(), + "unexpected errors: {:?}", + outcome.errors + ); + assert_eq!( + outcome.skills, + vec![SkillMetadata { + name: "ui-skill".to_string(), + description: "from toml".to_string(), + short_description: None, + interface: Some(SkillInterface { + display_name: Some("UI Skill".to_string()), + short_description: Some("short desc".to_string()), + icon_small: Some(normalized_skill_dir.join("./assets/small-400px.png")), + icon_large: Some(normalized_skill_dir.join("./assets/large-logo.svg")), + brand_color: Some("#3B82F6".to_string()), + default_prompt: Some("default prompt".to_string()), + }), + path: normalized(&skill_path), + scope: SkillScope::User, + }] + ); + } + + #[tokio::test] + async fn accepts_icon_paths_under_assets_dir() { + let codex_home = tempfile::tempdir().expect("tempdir"); + let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from toml"); + let skill_dir = skill_path.parent().expect("skill dir"); + let normalized_skill_dir = normalized(skill_dir); + + write_skill_interface_at( + skill_dir, + r#" +[interface] +display_name = "UI Skill" +icon_small = "assets/icon.png" +icon_large = "./assets/logo.svg" +"#, + ); + + let cfg = make_config(&codex_home).await; + let outcome = load_skills(&cfg); + + assert!( + outcome.errors.is_empty(), + "unexpected errors: {:?}", + outcome.errors + ); + assert_eq!( + outcome.skills, + vec![SkillMetadata { + name: "ui-skill".to_string(), + description: "from toml".to_string(), + short_description: None, + interface: Some(SkillInterface { + display_name: Some("UI Skill".to_string()), + short_description: None, + icon_small: Some(normalized_skill_dir.join("assets/icon.png")), + icon_large: Some(normalized_skill_dir.join("./assets/logo.svg")), + brand_color: None, + default_prompt: None, + }), + path: normalized(&skill_path), + scope: SkillScope::User, + }] + ); + } + + #[tokio::test] + async fn ignores_invalid_brand_color() { + let codex_home = tempfile::tempdir().expect("tempdir"); + let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from toml"); + let skill_dir = skill_path.parent().expect("skill dir"); + + write_skill_interface_at( + skill_dir, + r#" +[interface] +brand_color = "blue" +"#, + ); + + let cfg = make_config(&codex_home).await; + let outcome = load_skills(&cfg); + + assert!( + outcome.errors.is_empty(), + "unexpected errors: {:?}", + outcome.errors + ); + assert_eq!( + outcome.skills, + vec![SkillMetadata { + name: "ui-skill".to_string(), + description: "from toml".to_string(), + short_description: None, + interface: None, + path: normalized(&skill_path), + scope: SkillScope::User, + }] + ); + } + + #[tokio::test] + async fn ignores_default_prompt_over_max_length() { + let codex_home = tempfile::tempdir().expect("tempdir"); + let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from toml"); + let skill_dir = skill_path.parent().expect("skill dir"); + let normalized_skill_dir = normalized(skill_dir); + let too_long = "x".repeat(MAX_DEFAULT_PROMPT_LEN + 1); + + write_skill_interface_at( + skill_dir, + &format!( + r##" +[interface] +display_name = "UI Skill" +icon_small = "./assets/small-400px.png" +default_prompt = "{too_long}" +"## + ), + ); + + let cfg = make_config(&codex_home).await; + let outcome = load_skills(&cfg); + + assert!( + outcome.errors.is_empty(), + "unexpected errors: {:?}", + outcome.errors + ); + assert_eq!( + outcome.skills, + vec![SkillMetadata { + name: "ui-skill".to_string(), + description: "from toml".to_string(), + short_description: None, + interface: Some(SkillInterface { + display_name: Some("UI Skill".to_string()), + short_description: None, + icon_small: Some(normalized_skill_dir.join("./assets/small-400px.png")), + icon_large: None, + brand_color: None, + default_prompt: None, + }), + path: normalized(&skill_path), + scope: SkillScope::User, + }] + ); + } + + #[tokio::test] + async fn drops_interface_when_icons_are_invalid() { + let codex_home = tempfile::tempdir().expect("tempdir"); + let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from toml"); + let skill_dir = skill_path.parent().expect("skill dir"); + + write_skill_interface_at( + skill_dir, + r#" +[interface] +icon_small = "icon.png" +icon_large = "./assets/../logo.svg" +"#, + ); + + let cfg = make_config(&codex_home).await; + let outcome = load_skills(&cfg); + + assert!( + outcome.errors.is_empty(), + "unexpected errors: {:?}", + outcome.errors + ); + assert_eq!( + outcome.skills, + vec![SkillMetadata { + name: "ui-skill".to_string(), + description: "from toml".to_string(), + short_description: None, + interface: None, + path: normalized(&skill_path), + scope: SkillScope::User, + }] + ); + } + #[cfg(unix)] fn symlink_dir(target: &Path, link: &Path) { std::os::unix::fs::symlink(target, link).unwrap(); @@ -563,6 +917,7 @@ mod tests { name: "linked-skill".to_string(), description: "from link".to_string(), short_description: None, + interface: None, path: normalized(&shared_skill_path), scope: SkillScope::User, }] @@ -571,7 +926,7 @@ mod tests { #[tokio::test] #[cfg(unix)] - async fn loads_skills_via_symlinked_skill_file_for_user_scope() { + async fn ignores_symlinked_skill_file_for_user_scope() { let codex_home = tempfile::tempdir().expect("tempdir"); let shared = tempfile::tempdir().expect("tempdir"); @@ -590,16 +945,7 @@ mod tests { "unexpected errors: {:?}", outcome.errors ); - assert_eq!( - outcome.skills, - vec![SkillMetadata { - name: "linked-file-skill".to_string(), - description: "from link".to_string(), - short_description: None, - path: normalized(&shared_skill_path), - scope: SkillScope::User, - }] - ); + assert_eq!(outcome.skills, Vec::new()); } #[tokio::test] @@ -629,6 +975,7 @@ mod tests { name: "cycle-skill".to_string(), description: "still loads".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::User, }] @@ -662,6 +1009,7 @@ mod tests { name: "admin-linked-skill".to_string(), description: "from link".to_string(), short_description: None, + interface: None, path: normalized(&shared_skill_path), scope: SkillScope::Admin, }] @@ -699,6 +1047,7 @@ mod tests { name: "repo-linked-skill".to_string(), description: "from link".to_string(), short_description: None, + interface: None, path: normalized(&linked_skill_path), scope: SkillScope::Repo, }] @@ -759,6 +1108,7 @@ mod tests { name: "within-depth-skill".to_string(), description: "loads".to_string(), short_description: None, + interface: None, path: normalized(&within_depth_path), scope: SkillScope::User, }] @@ -783,6 +1133,7 @@ mod tests { name: "demo-skill".to_string(), description: "does things carefully".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::User, }] @@ -811,6 +1162,7 @@ mod tests { name: "demo-skill".to_string(), description: "long description".to_string(), short_description: Some("short summary".to_string()), + interface: None, path: normalized(&skill_path), scope: SkillScope::User, }] @@ -920,6 +1272,7 @@ mod tests { name: "repo-skill".to_string(), description: "from repo".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::Repo, }] @@ -970,6 +1323,7 @@ mod tests { name: "nested-skill".to_string(), description: "from nested".to_string(), short_description: None, + interface: None, path: normalized(&nested_skill_path), scope: SkillScope::Repo, }, @@ -977,6 +1331,7 @@ mod tests { name: "root-skill".to_string(), description: "from root".to_string(), short_description: None, + interface: None, path: normalized(&root_skill_path), scope: SkillScope::Repo, }, @@ -1013,6 +1368,7 @@ mod tests { name: "local-skill".to_string(), description: "from cwd".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::Repo, }] @@ -1050,6 +1406,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from repo".to_string(), short_description: None, + interface: None, path: normalized(&repo_skill_path), scope: SkillScope::Repo, }] @@ -1077,6 +1434,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from user".to_string(), short_description: None, + interface: None, path: normalized(&user_skill_path), scope: SkillScope::User, }] @@ -1145,6 +1503,7 @@ mod tests { name: "repo-skill".to_string(), description: "from repo".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::Repo, }] @@ -1200,6 +1559,7 @@ mod tests { name: "system-skill".to_string(), description: "from system".to_string(), short_description: None, + interface: None, path: normalized(&skill_path), scope: SkillScope::System, }] @@ -1254,6 +1614,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from system".to_string(), short_description: None, + interface: None, path: normalized(&system_skill_path), scope: SkillScope::System, }] @@ -1283,6 +1644,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from user".to_string(), short_description: None, + interface: None, path: normalized(&user_skill_path), scope: SkillScope::User, }] @@ -1321,6 +1683,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from repo".to_string(), short_description: None, + interface: None, path: normalized(&repo_skill_path), scope: SkillScope::Repo, }] @@ -1371,6 +1734,7 @@ mod tests { name: "dupe-skill".to_string(), description: "from nested".to_string(), short_description: None, + interface: None, path: expected_path, scope: SkillScope::Repo, }], diff --git a/codex-rs/core/src/skills/model.rs b/codex-rs/core/src/skills/model.rs index 9063d7a250..fba00d2711 100644 --- a/codex-rs/core/src/skills/model.rs +++ b/codex-rs/core/src/skills/model.rs @@ -7,10 +7,21 @@ pub struct SkillMetadata { pub name: String, pub description: String, pub short_description: Option, + pub interface: Option, pub path: PathBuf, pub scope: SkillScope, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SkillInterface { + pub display_name: Option, + pub short_description: Option, + pub icon_small: Option, + pub icon_large: Option, + pub brand_color: Option, + pub default_prompt: Option, +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct SkillError { pub path: PathBuf, diff --git a/codex-rs/core/src/tasks/review.rs b/codex-rs/core/src/tasks/review.rs index 353189a6be..9157e922ec 100644 --- a/codex-rs/core/src/tasks/review.rs +++ b/codex-rs/core/src/tasks/review.rs @@ -86,7 +86,7 @@ async fn start_review_conversation( let mut sub_agent_config = config.as_ref().clone(); // Carry over review-only feature restrictions so the delegate cannot // re-enable blocked tools (web search, view image). - sub_agent_config.web_search_mode = WebSearchMode::Disabled; + sub_agent_config.web_search_mode = Some(WebSearchMode::Disabled); // Set explicit review rubric for the sub-agent sub_agent_config.base_instructions = Some(crate::REVIEW_PROMPT.to_string()); diff --git a/codex-rs/core/src/tools/handlers/collab.rs b/codex-rs/core/src/tools/handlers/collab.rs index 805af76b3a..df3f2901da 100644 --- a/codex-rs/core/src/tools/handlers/collab.rs +++ b/codex-rs/core/src/tools/handlers/collab.rs @@ -76,11 +76,13 @@ impl ToolHandler for CollabHandler { mod spawn { use super::*; + use crate::agent::AgentRole; use std::sync::Arc; #[derive(Debug, Deserialize)] struct SpawnAgentArgs { message: String, + agent_type: Option, } #[derive(Debug, Serialize)] @@ -95,6 +97,7 @@ mod spawn { arguments: String, ) -> Result { let args: SpawnAgentArgs = parse_arguments(&arguments)?; + let agent_role = args.agent_type.unwrap_or(AgentRole::Default); let prompt = args.message; if prompt.trim().is_empty() { return Err(FunctionCallError::RespondToModel( @@ -112,7 +115,10 @@ mod spawn { .into(), ) .await; - let config = build_agent_spawn_config(turn.as_ref())?; + let mut config = build_agent_spawn_config(turn.as_ref())?; + agent_role + .apply_to_config(&mut config) + .map_err(FunctionCallError::RespondToModel)?; let result = session .services .agent_control @@ -164,6 +170,8 @@ mod send_input { struct SendInputArgs { id: String, message: String, + #[serde(default)] + interrupt: bool, } #[derive(Debug, Serialize)] @@ -185,6 +193,14 @@ mod send_input { "Empty message can't be sent to an agent".to_string(), )); } + if args.interrupt { + session + .services + .agent_control + .interrupt_agent(receiver_thread_id) + .await + .map_err(|err| collab_agent_error(receiver_thread_id, err))?; + } session .send_event( &turn, @@ -717,6 +733,45 @@ mod tests { ); } + #[tokio::test] + async fn send_input_interrupts_before_prompt() { + let (mut session, turn) = make_session_and_context().await; + let manager = thread_manager(); + session.services.agent_control = manager.agent_control(); + let config = turn.client.config().as_ref().clone(); + let thread = manager.start_thread(config).await.expect("start thread"); + let agent_id = thread.thread_id; + let invocation = invocation( + Arc::new(session), + Arc::new(turn), + "send_input", + function_payload(json!({ + "id": agent_id.to_string(), + "message": "hi", + "interrupt": true + })), + ); + CollabHandler + .handle(invocation) + .await + .expect("send_input should succeed"); + + let ops = manager.captured_ops(); + let ops_for_agent: Vec<&Op> = ops + .iter() + .filter_map(|(id, op)| (*id == agent_id).then_some(op)) + .collect(); + assert_eq!(ops_for_agent.len(), 2); + assert!(matches!(ops_for_agent[0], Op::Interrupt)); + assert!(matches!(ops_for_agent[1], Op::UserInput { .. })); + + let _ = thread + .thread + .submit(Op::Shutdown {}) + .await + .expect("shutdown should submit"); + } + #[tokio::test] async fn wait_rejects_non_positive_timeout() { let (session, turn) = make_session_and_context().await; diff --git a/codex-rs/core/src/tools/spec.rs b/codex-rs/core/src/tools/spec.rs index 28fc3a1701..5a35f2b648 100644 --- a/codex-rs/core/src/tools/spec.rs +++ b/codex-rs/core/src/tools/spec.rs @@ -1,3 +1,4 @@ +use crate::agent::AgentRole; use crate::client_common::tools::ResponsesApiTool; use crate::client_common::tools::ToolSpec; use crate::features::Feature; @@ -24,7 +25,7 @@ use std::collections::HashMap; pub(crate) struct ToolsConfig { pub shell_type: ConfigShellToolType, pub apply_patch_tool_type: Option, - pub web_search_mode: WebSearchMode, + pub web_search_mode: Option, pub collab_tools: bool, pub experimental_supported_tools: Vec, } @@ -32,7 +33,7 @@ pub(crate) struct ToolsConfig { pub(crate) struct ToolsConfigParams<'a> { pub(crate) model_info: &'a ModelInfo, pub(crate) features: &'a Features, - pub(crate) web_search_mode: WebSearchMode, + pub(crate) web_search_mode: Option, } impl ToolsConfig { @@ -441,6 +442,15 @@ fn create_spawn_agent_tool() -> ToolSpec { description: Some("Initial message to send to the new agent.".to_string()), }, ); + properties.insert( + "agent_type".to_string(), + JsonSchema::String { + description: Some(format!( + "Optional agent type to spawn ({}).", + AgentRole::enum_values().join(", ") + )), + }, + ); ToolSpec::Function(ResponsesApiTool { name: "spawn_agent".to_string(), @@ -468,6 +478,15 @@ fn create_send_input_tool() -> ToolSpec { description: Some("Message to send to the agent.".to_string()), }, ); + properties.insert( + "interrupt".to_string(), + JsonSchema::Boolean { + description: Some( + "When true, interrupt the agent's current task before sending the message. When false (default), the message will be processed when the agent is done on its current task." + .to_string(), + ), + }, + ); ToolSpec::Function(ResponsesApiTool { name: "send_input".to_string(), @@ -1225,17 +1244,17 @@ pub(crate) fn build_specs( } match config.web_search_mode { - WebSearchMode::Disabled => {} - WebSearchMode::Cached => { + Some(WebSearchMode::Cached) => { builder.push_spec(ToolSpec::WebSearch { external_web_access: Some(false), }); } - WebSearchMode::Live => { + Some(WebSearchMode::Live) => { builder.push_spec(ToolSpec::WebSearch { external_web_access: Some(true), }); } + Some(WebSearchMode::Disabled) | None => {} } builder.push_spec_with_parallel_support(create_view_image_tool(), true); @@ -1379,7 +1398,7 @@ mod tests { let config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Live, + web_search_mode: Some(WebSearchMode::Live), }); let (tools, _) = build_specs(&config, None).build(); @@ -1441,7 +1460,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs(&tools_config, None).build(); assert_contains_tool_names( @@ -1453,7 +1472,7 @@ mod tests { fn assert_model_tools( model_slug: &str, features: &Features, - web_search_mode: WebSearchMode, + web_search_mode: Option, expected_tools: &[&str], ) { let config = test_config(); @@ -1477,7 +1496,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs(&tools_config, None).build(); @@ -1499,7 +1518,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Live, + web_search_mode: Some(WebSearchMode::Live), }); let (tools, _) = build_specs(&tools_config, None).build(); @@ -1517,7 +1536,7 @@ mod tests { assert_model_tools( "gpt-5-codex", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "shell_command", "list_mcp_resources", @@ -1536,7 +1555,7 @@ mod tests { assert_model_tools( "gpt-5.1-codex", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "shell_command", "list_mcp_resources", @@ -1555,7 +1574,7 @@ mod tests { assert_model_tools( "gpt-5-codex", Features::with_defaults().enable(Feature::UnifiedExec), - WebSearchMode::Live, + Some(WebSearchMode::Live), &[ "exec_command", "write_stdin", @@ -1575,7 +1594,7 @@ mod tests { assert_model_tools( "gpt-5.1-codex", Features::with_defaults().enable(Feature::UnifiedExec), - WebSearchMode::Live, + Some(WebSearchMode::Live), &[ "exec_command", "write_stdin", @@ -1595,7 +1614,7 @@ mod tests { assert_model_tools( "codex-mini-latest", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "local_shell", "list_mcp_resources", @@ -1613,7 +1632,7 @@ mod tests { assert_model_tools( "gpt-5.1-codex-mini", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "shell_command", "list_mcp_resources", @@ -1632,7 +1651,7 @@ mod tests { assert_model_tools( "gpt-5", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "shell", "list_mcp_resources", @@ -1650,7 +1669,7 @@ mod tests { assert_model_tools( "gpt-5.1", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "shell_command", "list_mcp_resources", @@ -1669,7 +1688,7 @@ mod tests { assert_model_tools( "exp-5.1", &Features::with_defaults(), - WebSearchMode::Cached, + Some(WebSearchMode::Cached), &[ "exec_command", "write_stdin", @@ -1689,7 +1708,7 @@ mod tests { assert_model_tools( "codex-mini-latest", Features::with_defaults().enable(Feature::UnifiedExec), - WebSearchMode::Live, + Some(WebSearchMode::Live), &[ "exec_command", "write_stdin", @@ -1712,7 +1731,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Live, + web_search_mode: Some(WebSearchMode::Live), }); let (tools, _) = build_specs(&tools_config, Some(HashMap::new())).build(); @@ -1734,7 +1753,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs(&tools_config, None).build(); @@ -1753,7 +1772,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs(&tools_config, None).build(); @@ -1784,7 +1803,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Live, + web_search_mode: Some(WebSearchMode::Live), }); let (tools, _) = build_specs( &tools_config, @@ -1879,7 +1898,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); // Intentionally construct a map with keys that would sort alphabetically. @@ -1956,7 +1975,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs( @@ -2013,7 +2032,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs( @@ -2067,7 +2086,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs( @@ -2123,7 +2142,7 @@ mod tests { let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs( @@ -2235,7 +2254,7 @@ Examples of valid command strings: let tools_config = ToolsConfig::new(&ToolsConfigParams { model_info: &model_info, features: &features, - web_search_mode: WebSearchMode::Cached, + web_search_mode: Some(WebSearchMode::Cached), }); let (tools, _) = build_specs( &tools_config, diff --git a/codex-rs/core/templates/agents/orchestrator.md b/codex-rs/core/templates/agents/orchestrator.md new file mode 100644 index 0000000000..89d98c9334 --- /dev/null +++ b/codex-rs/core/templates/agents/orchestrator.md @@ -0,0 +1,38 @@ +You are Codex Orchestrator, based on GPT-5. You are running as an orchestration agent in the Codex CLI on a user's computer. + +## Role +- The interface between the user and the workers. Your role is to understand a problem and then delegate/coordinate workers to solve the task. +- Monitor progress, resolve conflicts, and integrate results into a single, coherent outcome. +- You can perform basic actions such as code exploration or running basic commands if needed to understand the problem, but you must delegate the hard work to workers. +- If a task can be split in well scoped sub-tasks, use multiple workers to solve it, and you take care of the global orchestration. +- Your job is not finished before the entire task is completed. While this is not the case, keep monitoring and coordinating your workers. +- Do not rush the workers. If they are working, let them work and don't ask them to "finalize now" unless requested by the user. + +## Multi-agent workflow + +1. Understand the request and identify the optimal set of workers needed. +2. Spawn worker(s) with precise goals, constraints, and expected deliverables. +3. Monitor workers with `wait`, route questions via `send_input`, and keep scope boundaries clear. +4. When all workers report done, verify their work to make sure the task was correctly solved. +5. If you spot issues, assign fixes to the relevant worker(s) and repeat steps 3–5 until the task is correctly completed. +6. Close all agents when you don't need them anymore (i.e. when the task if fully finished). + +## Collaboration rules + +- Tell every worker they are not alone in the environment and must not revert or overwrite others' work. +- Default: workers must not spawn sub-agents unless you explicitly allow it. +- When multiple workers are running, you can provide multiple ids to `wait` in order to wait for the first worker to finish. This will make your workflow event-based as the tool will return when the first agent is done (i.e. when you need to react on it). + +## Collab tools + +- `spawn_agent`: create a worker with an initial prompt (set `agent_type`). +- `send_input`: send follow-ups, clarifications, or fix requests (`interrupt` can stop the current task first). +- `wait`: poll the completion status of a list of workers. Return once at least one worker in the list is done. +- `close_agent`: close the agent when done. + +## Presenting your work and final message + +- Keep responses concise, factual, and in plain text. +- Summarize: what was delegated, key outcomes, tests/verification status, and any remaining risks. +- If verification failed, state the issues clearly and what you asked workers to change. +- Do not dump large files; reference paths with backticks. diff --git a/codex-rs/core/tests/responses_headers.rs b/codex-rs/core/tests/responses_headers.rs index 8be6e36340..8eba3eabe7 100644 --- a/codex-rs/core/tests/responses_headers.rs +++ b/codex-rs/core/tests/responses_headers.rs @@ -9,15 +9,18 @@ use codex_core::ModelProviderInfo; use codex_core::Prompt; use codex_core::ResponseEvent; use codex_core::ResponseItem; +use codex_core::WEB_SEARCH_ELIGIBLE_HEADER; use codex_core::WireApi; use codex_core::models_manager::manager::ModelsManager; use codex_otel::OtelManager; use codex_protocol::ThreadId; use codex_protocol::config_types::ReasoningSummary; +use codex_protocol::config_types::WebSearchMode; use codex_protocol::protocol::SessionSource; use codex_protocol::protocol::SubAgentSource; use core_test_support::load_default_config_for_test; use core_test_support::responses; +use core_test_support::test_codex::test_codex; use futures::StreamExt; use tempfile::TempDir; use wiremock::matchers::header; @@ -213,6 +216,66 @@ async fn responses_stream_includes_subagent_header_on_other() { ); } +#[tokio::test] +async fn responses_stream_includes_web_search_eligible_header_true_by_default() { + core_test_support::skip_if_no_network!(); + + let server = responses::start_mock_server().await; + let response_body = responses::sse(vec![ + responses::ev_response_created("resp-1"), + responses::ev_completed("resp-1"), + ]); + + let request_recorder = responses::mount_sse_once_match( + &server, + header(WEB_SEARCH_ELIGIBLE_HEADER, "true"), + response_body, + ) + .await; + + let test = test_codex().build(&server).await.expect("build test codex"); + test.submit_turn("hello").await.expect("submit test prompt"); + + let request = request_recorder.single_request(); + assert_eq!( + request.header(WEB_SEARCH_ELIGIBLE_HEADER).as_deref(), + Some("true") + ); +} + +#[tokio::test] +async fn responses_stream_includes_web_search_eligible_header_false_when_disabled() { + core_test_support::skip_if_no_network!(); + + let server = responses::start_mock_server().await; + let response_body = responses::sse(vec![ + responses::ev_response_created("resp-1"), + responses::ev_completed("resp-1"), + ]); + + let request_recorder = responses::mount_sse_once_match( + &server, + header(WEB_SEARCH_ELIGIBLE_HEADER, "false"), + response_body, + ) + .await; + + let test = test_codex() + .with_config(|config| { + config.web_search_mode = Some(WebSearchMode::Disabled); + }) + .build(&server) + .await + .expect("build test codex"); + test.submit_turn("hello").await.expect("submit test prompt"); + + let request = request_recorder.single_request(); + assert_eq!( + request.header(WEB_SEARCH_ELIGIBLE_HEADER).as_deref(), + Some("false") + ); +} + #[tokio::test] async fn responses_respects_model_info_overrides_from_config() { core_test_support::skip_if_no_network!(); diff --git a/codex-rs/core/tests/suite/client.rs b/codex-rs/core/tests/suite/client.rs index 18d3caf3bf..6f659e1b64 100644 --- a/codex-rs/core/tests/suite/client.rs +++ b/codex-rs/core/tests/suite/client.rs @@ -14,6 +14,7 @@ use codex_core::ThreadManager; use codex_core::WireApi; use codex_core::auth::AuthCredentialsStoreMode; use codex_core::built_in_model_providers; +use codex_core::default_client::originator; use codex_core::error::CodexErr; use codex_core::models_manager::manager::ModelsManager; use codex_core::protocol::EventMsg; @@ -406,7 +407,7 @@ async fn includes_conversation_id_and_model_headers_in_request() { let request_originator = request.header("originator").expect("originator header"); assert_eq!(request_session_id, session_id.to_string()); - assert_eq!(request_originator, "codex_cli_rs"); + assert_eq!(request_originator, originator().value); assert_eq!(request_authorization, "Bearer Test API Key"); } @@ -522,7 +523,7 @@ async fn chatgpt_auth_sends_correct_request() { let session_id = request.header("session_id").expect("session_id header"); assert_eq!(session_id, thread_id.to_string()); - assert_eq!(request_originator, "codex_cli_rs"); + assert_eq!(request_originator, originator().value); assert_eq!(request_authorization, "Bearer Access Token"); assert_eq!(request_chatgpt_account_id, "account_id"); assert!(request_body["stream"].as_bool().unwrap()); diff --git a/codex-rs/core/tests/suite/items.rs b/codex-rs/core/tests/suite/items.rs index ce9b0f1340..20739ab0db 100644 --- a/codex-rs/core/tests/suite/items.rs +++ b/codex-rs/core/tests/suite/items.rs @@ -6,6 +6,8 @@ use codex_core::protocol::ItemCompletedEvent; use codex_core::protocol::ItemStartedEvent; use codex_core::protocol::Op; use codex_protocol::items::TurnItem; +use codex_protocol::user_input::ByteRange; +use codex_protocol::user_input::TextElement; use codex_protocol::user_input::UserInput; use core_test_support::responses::ev_assistant_message; use core_test_support::responses::ev_completed; @@ -38,12 +40,18 @@ async fn user_message_item_is_emitted() -> anyhow::Result<()> { let first_response = sse(vec![ev_response_created("resp-1"), ev_completed("resp-1")]); mount_sse_once(&server, first_response).await; + let text_elements = vec![TextElement { + byte_range: ByteRange { start: 0, end: 6 }, + placeholder: Some("".into()), + }]; + let expected_input = UserInput::Text { + text: "please inspect sample.txt".into(), + text_elements: text_elements.clone(), + }; + codex .submit(Op::UserInput { - items: (vec![UserInput::Text { - text: "please inspect sample.txt".into(), - text_elements: Vec::new(), - }]), + items: vec![expected_input.clone()], final_output_json_schema: None, }) .await?; @@ -66,20 +74,16 @@ async fn user_message_item_is_emitted() -> anyhow::Result<()> { .await; assert_eq!(started_item.id, completed_item.id); - assert_eq!( - started_item.content, - vec![UserInput::Text { - text: "please inspect sample.txt".into(), - text_elements: Vec::new(), - }] - ); - assert_eq!( - completed_item.content, - vec![UserInput::Text { - text: "please inspect sample.txt".into(), - text_elements: Vec::new(), - }] - ); + assert_eq!(started_item.content, vec![expected_input.clone()]); + assert_eq!(completed_item.content, vec![expected_input]); + + let legacy_message = wait_for_event_match(&codex, |ev| match ev { + EventMsg::UserMessage(event) => Some(event.clone()), + _ => None, + }) + .await; + assert_eq!(legacy_message.message, "please inspect sample.txt"); + assert_eq!(legacy_message.text_elements, text_elements); Ok(()) } diff --git a/codex-rs/core/tests/suite/model_tools.rs b/codex-rs/core/tests/suite/model_tools.rs index 4eaf3735a3..8a4d0a7717 100644 --- a/codex-rs/core/tests/suite/model_tools.rs +++ b/codex-rs/core/tests/suite/model_tools.rs @@ -36,7 +36,7 @@ async fn collect_tool_identifiers_for_model(model: &str) -> Vec { let mut builder = test_codex() .with_model(model) // Keep tool expectations stable when the default web_search mode changes. - .with_config(|config| config.web_search_mode = WebSearchMode::Cached); + .with_config(|config| config.web_search_mode = Some(WebSearchMode::Cached)); let test = builder .build(&server) .await diff --git a/codex-rs/core/tests/suite/prompt_caching.rs b/codex-rs/core/tests/suite/prompt_caching.rs index b3ed78f69d..6ea5619bfe 100644 --- a/codex-rs/core/tests/suite/prompt_caching.rs +++ b/codex-rs/core/tests/suite/prompt_caching.rs @@ -88,7 +88,7 @@ async fn prompt_tools_are_consistent_across_requests() -> anyhow::Result<()> { config.user_instructions = Some("be consistent and helpful".to_string()); config.model = Some("gpt-5.1-codex-max".to_string()); // Keep tool expectations stable when the default web_search mode changes. - config.web_search_mode = WebSearchMode::Cached; + config.web_search_mode = Some(WebSearchMode::Cached); }) .build(&server) .await?; diff --git a/codex-rs/core/tests/suite/resume.rs b/codex-rs/core/tests/suite/resume.rs index 8424146d65..8912870e5e 100644 --- a/codex-rs/core/tests/suite/resume.rs +++ b/codex-rs/core/tests/suite/resume.rs @@ -1,6 +1,8 @@ use anyhow::Result; use codex_core::protocol::EventMsg; use codex_core::protocol::Op; +use codex_protocol::user_input::ByteRange; +use codex_protocol::user_input::TextElement; use codex_protocol::user_input::UserInput; use core_test_support::responses::ev_assistant_message; use core_test_support::responses::ev_completed; @@ -12,6 +14,7 @@ use core_test_support::responses::start_mock_server; use core_test_support::skip_if_no_network; use core_test_support::test_codex::test_codex; use core_test_support::wait_for_event; +use pretty_assertions::assert_eq; use std::sync::Arc; #[tokio::test(flavor = "multi_thread", worker_threads = 2)] @@ -32,11 +35,16 @@ async fn resume_includes_initial_messages_from_rollout_events() -> Result<()> { ]); mount_sse_once(&server, initial_sse).await; + let text_elements = vec![TextElement { + byte_range: ByteRange { start: 0, end: 6 }, + placeholder: Some("".into()), + }]; + codex .submit(Op::UserInput { items: vec![UserInput::Text { text: "Record some messages".into(), - text_elements: Vec::new(), + text_elements: text_elements.clone(), }], final_output_json_schema: None, }) @@ -57,6 +65,7 @@ async fn resume_includes_initial_messages_from_rollout_events() -> Result<()> { EventMsg::TokenCount(_), ] => { assert_eq!(first_user.message, "Record some messages"); + assert_eq!(first_user.text_elements, text_elements); assert_eq!(assistant_message.message, "Completed first turn"); } other => panic!("unexpected initial messages after resume: {other:#?}"), diff --git a/codex-rs/core/tests/suite/rmcp_client.rs b/codex-rs/core/tests/suite/rmcp_client.rs index 5001eead32..5abc392644 100644 --- a/codex-rs/core/tests/suite/rmcp_client.rs +++ b/codex-rs/core/tests/suite/rmcp_client.rs @@ -88,6 +88,7 @@ async fn stdio_server_round_trip() -> anyhow::Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -225,6 +226,7 @@ async fn stdio_image_responses_round_trip() -> anyhow::Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -420,6 +422,7 @@ async fn stdio_image_completions_round_trip() -> anyhow::Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -563,6 +566,7 @@ async fn stdio_server_propagates_whitelisted_env_vars() -> anyhow::Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -717,6 +721,7 @@ async fn streamable_http_tool_call_round_trip() -> anyhow::Result<()> { env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -903,6 +908,7 @@ async fn streamable_http_with_oauth_round_trip() -> anyhow::Result<()> { env_http_headers: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/core/tests/suite/truncation.rs b/codex-rs/core/tests/suite/truncation.rs index a86489bdd0..4ae095517c 100644 --- a/codex-rs/core/tests/suite/truncation.rs +++ b/codex-rs/core/tests/suite/truncation.rs @@ -426,6 +426,7 @@ async fn mcp_tool_call_output_exceeds_limit_truncated_for_model() -> Result<()> cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(std::time::Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -517,6 +518,7 @@ async fn mcp_image_output_preserves_image_and_no_text_summary() -> Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, @@ -777,6 +779,7 @@ async fn mcp_tool_call_output_not_truncated_with_custom_limit() -> Result<()> { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: Some(std::time::Duration::from_secs(10)), tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/core/tests/suite/web_search_cached.rs b/codex-rs/core/tests/suite/web_search_cached.rs index 261efaf942..1a69d8b737 100644 --- a/codex-rs/core/tests/suite/web_search_cached.rs +++ b/codex-rs/core/tests/suite/web_search_cached.rs @@ -35,7 +35,7 @@ async fn web_search_mode_cached_sets_external_web_access_false_in_request_body() let mut builder = test_codex() .with_model("gpt-5-codex") .with_config(|config| { - config.web_search_mode = WebSearchMode::Cached; + config.web_search_mode = Some(WebSearchMode::Cached); }); let test = builder .build(&server) @@ -67,7 +67,7 @@ async fn web_search_mode_takes_precedence_over_legacy_flags_in_request_body() { .with_model("gpt-5-codex") .with_config(|config| { config.features.enable(Feature::WebSearchRequest); - config.web_search_mode = WebSearchMode::Cached; + config.web_search_mode = Some(WebSearchMode::Cached); }); let test = builder .build(&server) diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rs index 131e36ce22..966dc65346 100644 --- a/codex-rs/exec/src/lib.rs +++ b/codex-rs/exec/src/lib.rs @@ -557,6 +557,79 @@ fn load_output_schema(path: Option) -> Option { } } +#[derive(Debug, Clone, PartialEq, Eq)] +enum PromptDecodeError { + InvalidUtf8 { valid_up_to: usize }, + InvalidUtf16 { encoding: &'static str }, + UnsupportedBom { encoding: &'static str }, +} + +impl std::fmt::Display for PromptDecodeError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + PromptDecodeError::InvalidUtf8 { valid_up_to } => write!( + f, + "input is not valid UTF-8 (invalid byte at offset {valid_up_to}). Convert it to UTF-8 and retry (e.g., `iconv -f -t UTF-8 prompt.txt`)." + ), + PromptDecodeError::InvalidUtf16 { encoding } => write!( + f, + "input looked like {encoding} but could not be decoded. Convert it to UTF-8 and retry." + ), + PromptDecodeError::UnsupportedBom { encoding } => write!( + f, + "input appears to be {encoding}. Convert it to UTF-8 and retry." + ), + } + } +} + +fn decode_prompt_bytes(input: &[u8]) -> Result { + let input = input.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(input); + + if input.starts_with(&[0xFF, 0xFE, 0x00, 0x00]) { + return Err(PromptDecodeError::UnsupportedBom { + encoding: "UTF-32LE", + }); + } + + if input.starts_with(&[0x00, 0x00, 0xFE, 0xFF]) { + return Err(PromptDecodeError::UnsupportedBom { + encoding: "UTF-32BE", + }); + } + + if let Some(rest) = input.strip_prefix(&[0xFF, 0xFE]) { + return decode_utf16(rest, "UTF-16LE", u16::from_le_bytes); + } + + if let Some(rest) = input.strip_prefix(&[0xFE, 0xFF]) { + return decode_utf16(rest, "UTF-16BE", u16::from_be_bytes); + } + + std::str::from_utf8(input) + .map(str::to_string) + .map_err(|e| PromptDecodeError::InvalidUtf8 { + valid_up_to: e.valid_up_to(), + }) +} + +fn decode_utf16( + input: &[u8], + encoding: &'static str, + decode_unit: fn([u8; 2]) -> u16, +) -> Result { + if !input.len().is_multiple_of(2) { + return Err(PromptDecodeError::InvalidUtf16 { encoding }); + } + + let units: Vec = input + .chunks_exact(2) + .map(|chunk| decode_unit([chunk[0], chunk[1]])) + .collect(); + + String::from_utf16(&units).map_err(|_| PromptDecodeError::InvalidUtf16 { encoding }) +} + fn resolve_prompt(prompt_arg: Option) -> String { match prompt_arg { Some(p) if p != "-" => p, @@ -573,11 +646,22 @@ fn resolve_prompt(prompt_arg: Option) -> String { if !force_stdin { eprintln!("Reading prompt from stdin..."); } - let mut buffer = String::new(); - if let Err(e) = std::io::stdin().read_to_string(&mut buffer) { + + let mut bytes = Vec::new(); + if let Err(e) = std::io::stdin().read_to_end(&mut bytes) { eprintln!("Failed to read prompt from stdin: {e}"); std::process::exit(1); - } else if buffer.trim().is_empty() { + } + + let buffer = match decode_prompt_bytes(&bytes) { + Ok(s) => s, + Err(e) => { + eprintln!("Failed to read prompt from stdin: {e}"); + std::process::exit(1); + } + }; + + if buffer.trim().is_empty() { eprintln!("No prompt provided via stdin."); std::process::exit(1); } @@ -682,4 +766,79 @@ mod tests { assert_eq!(request, expected); } + + #[test] + fn decode_prompt_bytes_strips_utf8_bom() { + let input = [0xEF, 0xBB, 0xBF, b'h', b'i', b'\n']; + + let out = decode_prompt_bytes(&input).expect("decode utf-8 with BOM"); + + assert_eq!(out, "hi\n"); + } + + #[test] + fn decode_prompt_bytes_decodes_utf16le_bom() { + // UTF-16LE BOM + "hi\n" + let input = [0xFF, 0xFE, b'h', 0x00, b'i', 0x00, b'\n', 0x00]; + + let out = decode_prompt_bytes(&input).expect("decode utf-16le with BOM"); + + assert_eq!(out, "hi\n"); + } + + #[test] + fn decode_prompt_bytes_decodes_utf16be_bom() { + // UTF-16BE BOM + "hi\n" + let input = [0xFE, 0xFF, 0x00, b'h', 0x00, b'i', 0x00, b'\n']; + + let out = decode_prompt_bytes(&input).expect("decode utf-16be with BOM"); + + assert_eq!(out, "hi\n"); + } + + #[test] + fn decode_prompt_bytes_rejects_utf32le_bom() { + // UTF-32LE BOM + "hi\n" + let input = [ + 0xFF, 0xFE, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i', 0x00, 0x00, 0x00, b'\n', 0x00, + 0x00, 0x00, + ]; + + let err = decode_prompt_bytes(&input).expect_err("utf-32le should be rejected"); + + assert_eq!( + err, + PromptDecodeError::UnsupportedBom { + encoding: "UTF-32LE" + } + ); + } + + #[test] + fn decode_prompt_bytes_rejects_utf32be_bom() { + // UTF-32BE BOM + "hi\n" + let input = [ + 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i', 0x00, 0x00, + 0x00, b'\n', + ]; + + let err = decode_prompt_bytes(&input).expect_err("utf-32be should be rejected"); + + assert_eq!( + err, + PromptDecodeError::UnsupportedBom { + encoding: "UTF-32BE" + } + ); + } + + #[test] + fn decode_prompt_bytes_rejects_invalid_utf8() { + // Invalid UTF-8 sequence: 0xC3 0x28 + let input = [0xC3, 0x28]; + + let err = decode_prompt_bytes(&input).expect_err("invalid utf-8 should fail"); + + assert_eq!(err, PromptDecodeError::InvalidUtf8 { valid_up_to: 0 }); + } } diff --git a/codex-rs/linux-sandbox/README.md b/codex-rs/linux-sandbox/README.md index 4d45b06e8d..676f234954 100644 --- a/codex-rs/linux-sandbox/README.md +++ b/codex-rs/linux-sandbox/README.md @@ -6,52 +6,3 @@ This crate is responsible for producing: - a lib crate that exposes the business logic of the executable as `run_main()` so that - the `codex-exec` CLI can check if its arg0 is `codex-linux-sandbox` and, if so, execute as if it were `codex-linux-sandbox` - this should also be true of the `codex` multitool CLI - -## Git safety mounts (Linux) - -When the sandbox policy allows workspace writes, the Linux sandbox uses a user -namespace plus a mount namespace to bind-mount sensitive subpaths read-only -before applying Landlock rules. This keeps Git and Codex metadata immutable -while still allowing writes to other workspace files, including worktree setups -where `.git` is a pointer file. - -Protected subpaths under each writable root include: - -- `.git` (directory or pointer file) -- the resolved `gitdir:` target when `.git` is a pointer file -- `.codex` when present - -### How this plays with Landlock - -Mount permissions and Landlock intersect: if a bind mount is read-only, writes -are denied even if Landlock would allow them. For that reason, the sandbox sets -up the read-only mounts *before* calling `landlock_restrict_self()` and then -applies Landlock rules on top. - -### Quick manual test - -Run the sandbox directly with a workspace-write policy (from a Git repository -root): - -```bash -codex-linux-sandbox \ - --sandbox-policy-cwd "$PWD" \ - --sandbox-policy '{"type":"workspace-write"}' \ - -- bash -lc ' -set -euo pipefail - -echo "should fail" > .git/config && exit 1 || true -echo "should fail" > .git/hooks/pre-commit && exit 1 || true -echo "should fail" > .git/index.lock && exit 1 || true -echo "should fail" > .codex/config.toml && exit 1 || true -echo "ok" > sandbox-write-test.txt -' -``` - -Expected behavior: - -- Writes to `.git/config` fail with `Read-only file system`. -- Creating or modifying files under `.git/hooks/` fails. -- Writing `.git/index.lock` fails (since `.git` is read-only). -- Writes under `.codex/` fail when the directory exists. -- Writing a normal repo file succeeds. diff --git a/codex-rs/linux-sandbox/src/landlock.rs b/codex-rs/linux-sandbox/src/landlock.rs index dab5a6bfce..772176fc90 100644 --- a/codex-rs/linux-sandbox/src/landlock.rs +++ b/codex-rs/linux-sandbox/src/landlock.rs @@ -7,8 +7,6 @@ use codex_core::error::SandboxErr; use codex_core::protocol::SandboxPolicy; use codex_utils_absolute_path::AbsolutePathBuf; -use crate::mounts::apply_read_only_mounts; - use landlock::ABI; use landlock::Access; use landlock::AccessFs; @@ -33,10 +31,6 @@ pub(crate) fn apply_sandbox_policy_to_current_thread( sandbox_policy: &SandboxPolicy, cwd: &Path, ) -> Result<()> { - if !sandbox_policy.has_full_disk_write_access() { - apply_read_only_mounts(sandbox_policy, cwd)?; - } - if !sandbox_policy.has_full_disk_write_access() || !sandbox_policy.has_full_network_access() { set_no_new_privs()?; } diff --git a/codex-rs/linux-sandbox/src/mounts.rs b/codex-rs/linux-sandbox/src/mounts.rs index bed732da14..04f3651dff 100644 --- a/codex-rs/linux-sandbox/src/mounts.rs +++ b/codex-rs/linux-sandbox/src/mounts.rs @@ -1,3 +1,5 @@ +#![allow(dead_code)] + use std::ffi::CString; use std::os::unix::ffi::OsStrExt; use std::path::Path; diff --git a/codex-rs/linux-sandbox/tests/suite/landlock.rs b/codex-rs/linux-sandbox/tests/suite/landlock.rs index cca049e049..663f3cbe21 100644 --- a/codex-rs/linux-sandbox/tests/suite/landlock.rs +++ b/codex-rs/linux-sandbox/tests/suite/landlock.rs @@ -13,7 +13,6 @@ use pretty_assertions::assert_eq; use std::collections::HashMap; use std::path::PathBuf; use tempfile::NamedTempFile; -use tokio::process::Command; // At least on GitHub CI, the arm64 tests appear to need longer timeouts. @@ -91,51 +90,6 @@ async fn run_cmd_output( .unwrap() } -#[expect(clippy::expect_used)] -async fn assert_write_blocked(cmd: &[&str], writable_roots: &[PathBuf], timeout_ms: u64) { - let cwd = std::env::current_dir().expect("cwd should exist"); - let sandbox_cwd = cwd.clone(); - let params = ExecParams { - command: cmd.iter().copied().map(str::to_owned).collect(), - cwd, - expiration: timeout_ms.into(), - env: create_env_from_core_vars(), - sandbox_permissions: SandboxPermissions::UseDefault, - justification: None, - arg0: None, - }; - - let sandbox_policy = SandboxPolicy::WorkspaceWrite { - writable_roots: writable_roots - .iter() - .map(|p| AbsolutePathBuf::try_from(p.as_path()).unwrap()) - .collect(), - network_access: false, - exclude_tmpdir_env_var: true, - exclude_slash_tmp: true, - }; - let sandbox_program = env!("CARGO_BIN_EXE_codex-linux-sandbox"); - let codex_linux_sandbox_exe = Some(PathBuf::from(sandbox_program)); - let result = process_exec_tool_call( - params, - &sandbox_policy, - sandbox_cwd.as_path(), - &codex_linux_sandbox_exe, - None, - ) - .await; - - match result { - Ok(output) => { - if output.exit_code == 0 { - panic!("expected command to fail, but exit code was 0"); - } - } - Err(CodexErr::Sandbox(SandboxErr::Denied { .. })) => {} - Err(err) => panic!("expected sandbox denial, got: {err:?}"), - } -} - #[tokio::test] async fn test_root_read() { run_cmd(&["ls", "-l", "/bin"], &[], SHORT_TIMEOUT_MS).await; @@ -201,134 +155,6 @@ async fn test_no_new_privs_is_enabled() { assert_eq!(line.trim(), "NoNewPrivs:\t1"); } -#[tokio::test] -async fn test_git_dir_write_blocked() { - let tmpdir = tempfile::tempdir().unwrap(); - let repo_root = tmpdir.path(); - Command::new("git") - .arg("init") - .arg(".") - .current_dir(repo_root) - .output() - .await - .expect("git init ."); - - let git_config = repo_root.join(".git").join("config"); - let git_index_lock = repo_root.join(".git").join("index.lock"); - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!("echo pwned > {}", git_config.to_string_lossy()), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!("echo pwned > {}", git_index_lock.to_string_lossy()), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; -} - -#[tokio::test] -async fn test_git_dir_move_blocked() { - let tmpdir = tempfile::tempdir().unwrap(); - let repo_root = tmpdir.path(); - Command::new("git") - .arg("init") - .arg(".") - .current_dir(repo_root) - .output() - .await - .expect("git init ."); - - let git_dir = repo_root.join(".git"); - let git_dir_backup = repo_root.join(".git.bak"); - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!( - "mv {} {}", - git_dir.to_string_lossy(), - git_dir_backup.to_string_lossy() - ), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; -} - -#[tokio::test] -async fn test_codex_dir_write_blocked() { - let tmpdir = tempfile::tempdir().unwrap(); - let repo_root = tmpdir.path(); - std::fs::create_dir_all(repo_root.join(".codex")).unwrap(); - - let codex_config = repo_root.join(".codex").join("config.toml"); - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!("echo pwned > {}", codex_config.to_string_lossy()), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; -} - -#[tokio::test] -async fn test_git_pointer_file_blocks_gitdir_writes() { - let tmpdir = tempfile::tempdir().unwrap(); - let repo_root = tmpdir.path(); - let gitdir = repo_root.join("actual-gitdir"); - std::fs::create_dir_all(&gitdir).unwrap(); - - let gitdir_config = gitdir.join("config"); - std::fs::write(&gitdir_config, "[core]\n\trepositoryformatversion = 0\n").unwrap(); - - std::fs::write( - repo_root.join(".git"), - format!("gitdir: {}\n", gitdir.to_string_lossy()), - ) - .unwrap(); - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!("echo pwned > {}", gitdir_config.to_string_lossy()), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; - - assert_write_blocked( - &[ - "bash", - "-lc", - &format!("echo pwned > {}", repo_root.join(".git").to_string_lossy()), - ], - &[repo_root.to_path_buf()], - LONG_TIMEOUT_MS, - ) - .await; -} - #[tokio::test] #[should_panic(expected = "Sandbox(Timeout")] async fn test_timeout() { diff --git a/codex-rs/protocol/src/items.rs b/codex-rs/protocol/src/items.rs index 9d6b484d92..cb04d427b9 100644 --- a/codex-rs/protocol/src/items.rs +++ b/codex-rs/protocol/src/items.rs @@ -4,6 +4,8 @@ use crate::protocol::AgentReasoningRawContentEvent; use crate::protocol::EventMsg; use crate::protocol::UserMessageEvent; use crate::protocol::WebSearchEndEvent; +use crate::user_input::ByteRange; +use crate::user_input::TextElement; use crate::user_input::UserInput; use schemars::JsonSchema; use serde::Deserialize; @@ -62,13 +64,13 @@ impl UserMessageItem { } pub fn as_legacy_event(&self) -> EventMsg { + // Legacy user-message events flatten only text inputs into `message` and + // rebase text element ranges onto that concatenated text. EventMsg::UserMessage(UserMessageEvent { message: self.message(), images: Some(self.image_urls()), - // TODO: Thread text element ranges into legacy user message events. - text_elements: Vec::new(), - // TODO: Thread local image paths into legacy user message events. - local_images: Vec::new(), + local_images: self.local_image_paths(), + text_elements: self.text_elements(), }) } @@ -83,6 +85,32 @@ impl UserMessageItem { .join("") } + pub fn text_elements(&self) -> Vec { + let mut out = Vec::new(); + let mut offset = 0usize; + for input in &self.content { + if let UserInput::Text { + text, + text_elements, + } = input + { + // Text element ranges are relative to each text chunk; offset them so they align + // with the concatenated message returned by `message()`. + for elem in text_elements { + out.push(TextElement { + byte_range: ByteRange { + start: offset + elem.byte_range.start, + end: offset + elem.byte_range.end, + }, + placeholder: elem.placeholder.clone(), + }); + } + offset += text.len(); + } + } + out + } + pub fn image_urls(&self) -> Vec { self.content .iter() @@ -92,6 +120,16 @@ impl UserMessageItem { }) .collect() } + + pub fn local_image_paths(&self) -> Vec { + self.content + .iter() + .filter_map(|c| match c { + UserInput::LocalImage { path } => Some(path.clone()), + _ => None, + }) + .collect() + } } impl AgentMessageItem { diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rs index 8b2484c748..cbaa35f033 100644 --- a/codex-rs/protocol/src/protocol.rs +++ b/codex-rs/protocol/src/protocol.rs @@ -1970,13 +1970,33 @@ pub enum SkillScope { pub struct SkillMetadata { pub name: String, pub description: String, - #[ts(optional)] #[serde(default, skip_serializing_if = "Option::is_none")] + #[ts(optional)] + /// Legacy short_description from SKILL.md. Prefer SKILL.toml interface.short_description. pub short_description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[ts(optional)] + pub interface: Option, pub path: PathBuf, pub scope: SkillScope, } +#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS, PartialEq, Eq)] +pub struct SkillInterface { + #[ts(optional)] + pub display_name: Option, + #[ts(optional)] + pub short_description: Option, + #[ts(optional)] + pub icon_small: Option, + #[ts(optional)] + pub icon_large: Option, + #[ts(optional)] + pub brand_color: Option, + #[ts(optional)] + pub default_prompt: Option, +} + #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)] pub struct SkillErrorInfo { pub path: PathBuf, diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index 848c63639d..f1d6ca5da4 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -589,7 +589,7 @@ impl App { // [tui-textarea]: https://github.com/rhysd/tui-textarea/blob/4d18622eeac13b309e0ff6a55a46ac6706da68cf/src/textarea.rs#L782-L783 // [iTerm2]: https://github.com/gnachman/iTerm2/blob/5d0c0d9f68523cbd0494dad5422998964a2ecd8d/sources/iTermPasteHelper.m#L206-L216 let pasted = pasted.replace("\r", "\n"); - self.chat_widget.handle_paste_event(pasted); + self.chat_widget.handle_paste(pasted); } TuiEvent::Draw => { self.chat_widget.maybe_post_pending_notification(tui); diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs index facfab622c..343403704e 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs @@ -2230,7 +2230,7 @@ impl Renderable for ChatComposer { .unwrap_or("Input disabled.") .to_string() }; - let placeholder = Span::from(text).dim().italic(); + let placeholder = Span::from(text).dim(); Line::from(vec![placeholder]).render_ref(textarea_rect.inner(Margin::new(0, 0)), buf); } } diff --git a/codex-rs/tui/src/bottom_pane/skill_popup.rs b/codex-rs/tui/src/bottom_pane/skill_popup.rs index 8e894de45e..867c10a8bf 100644 --- a/codex-rs/tui/src/bottom_pane/skill_popup.rs +++ b/codex-rs/tui/src/bottom_pane/skill_popup.rs @@ -87,12 +87,8 @@ impl SkillPopup { .into_iter() .map(|(idx, indices, _score)| { let skill = &self.skills[idx]; - let name = truncate_text(&skill.name, 21); - let description = skill - .short_description - .as_ref() - .unwrap_or(&skill.description) - .clone(); + let name = truncate_text(skill_display_name(skill), 21); + let description = skill_description(skill).to_string(); GenericDisplayRow { name, match_indices: indices, @@ -117,15 +113,20 @@ impl SkillPopup { } for (idx, skill) in self.skills.iter().enumerate() { - if let Some((indices, score)) = fuzzy_match(&skill.name, filter) { + let display_name = skill_display_name(skill); + if let Some((indices, score)) = fuzzy_match(display_name, filter) { out.push((idx, Some(indices), score)); + } else if display_name != skill.name + && let Some((_indices, score)) = fuzzy_match(&skill.name, filter) + { + out.push((idx, None, score)); } } out.sort_by(|a, b| { a.2.cmp(&b.2).then_with(|| { - let an = &self.skills[a.0].name; - let bn = &self.skills[b.0].name; + let an = skill_display_name(&self.skills[a.0]); + let bn = skill_display_name(&self.skills[b.0]); an.cmp(bn) }) }); @@ -177,3 +178,20 @@ fn skill_popup_hint_line() -> Line<'static> { " to close".into(), ]) } + +fn skill_display_name(skill: &SkillMetadata) -> &str { + skill + .interface + .as_ref() + .and_then(|interface| interface.display_name.as_deref()) + .unwrap_or(&skill.name) +} + +fn skill_description(skill: &SkillMetadata) -> &str { + skill + .interface + .as_ref() + .and_then(|interface| interface.short_description.as_deref()) + .or(skill.short_description.as_deref()) + .unwrap_or(&skill.description) +} diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index 6d9f9dafa6..3d566356e2 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -87,6 +87,7 @@ use codex_core::protocol::ViewImageToolCallEvent; use codex_core::protocol::WarningEvent; use codex_core::protocol::WebSearchBeginEvent; use codex_core::protocol::WebSearchEndEvent; +use codex_core::skills::model::SkillInterface; use codex_core::skills::model::SkillMetadata; use codex_protocol::ThreadId; use codex_protocol::account::PlanType; @@ -134,6 +135,7 @@ use crate::bottom_pane::SelectionViewParams; use crate::bottom_pane::custom_prompt_view::CustomPromptView; use crate::bottom_pane::popup_consts::standard_popup_hint_line; use crate::clipboard_paste::paste_image_to_temp_png; +use crate::collab; use crate::diff_render::display_path_for; use crate::exec_cell::CommandOutput; use crate::exec_cell::ExecCell; @@ -460,8 +462,17 @@ pub(crate) struct ChatWidget { is_review_mode: bool, // Snapshot of token usage to restore after review mode exits. pre_review_token_info: Option>, - // Whether to add a final message separator after the last message + // Whether the next streamed assistant content should be preceded by a final message separator. + // + // This is set whenever we insert a visible history cell that conceptually belongs to a turn. + // The separator itself is only rendered if the turn recorded "work" activity (see + // `had_work_activity`). needs_final_message_separator: bool, + // Whether the current turn performed "work" (exec commands, MCP tool calls, patch applications). + // + // This gates rendering of the "Worked for …" separator so purely conversational turns don't + // show an empty divider. It is reset when the separator is emitted. + had_work_activity: bool, last_rendered_width: std::cell::Cell>, // Feedback sink for /feedback @@ -744,6 +755,7 @@ impl ChatWidget { self.suppressed_exec_calls.clear(); self.last_unified_wait = None; self.unified_exec_wait_streak = None; + self.clear_unified_exec_processes(); self.request_redraw(); // If there is a queued user message, send exactly one now to begin the next turn. @@ -880,6 +892,7 @@ impl ChatWidget { self.running_commands.clear(); self.suppressed_exec_calls.clear(); self.last_unified_wait = None; + self.clear_unified_exec_processes(); self.stream_controller = None; self.maybe_show_pending_rate_limit_prompt(); } @@ -972,8 +985,6 @@ impl ChatWidget { fn on_interrupted_turn(&mut self, reason: TurnAbortReason) { // Finalize, log a gentle prompt, and clear running state. self.finalize_turn(); - self.unified_exec_processes.clear(); - self.sync_unified_exec_footer(); if reason != TurnAbortReason::ReviewEnded { self.add_to_history(history_cell::new_error_event( @@ -1194,6 +1205,14 @@ impl ChatWidget { self.bottom_pane.set_unified_exec_processes(processes); } + fn clear_unified_exec_processes(&mut self) { + if self.unified_exec_processes.is_empty() { + return; + } + self.unified_exec_processes.clear(); + self.sync_unified_exec_footer(); + } + fn on_mcp_tool_call_begin(&mut self, ev: McpToolCallBeginEvent) { let ev2 = ev.clone(); self.defer_or_handle(|q| q.push_mcp_begin(ev), |s| s.handle_mcp_begin_now(ev2)); @@ -1213,6 +1232,12 @@ impl ChatWidget { self.add_to_history(history_cell::new_web_search_call(ev.query)); } + fn on_collab_event(&mut self, cell: PlainHistoryCell) { + self.flush_answer_stream_with_separator(); + self.add_to_history(cell); + self.request_redraw(); + } + fn on_get_history_entry_response( &mut self, event: codex_core::protocol::GetHistoryEntryResponseEvent, @@ -1332,13 +1357,19 @@ impl ChatWidget { self.flush_active_cell(); if self.stream_controller.is_none() { - if self.needs_final_message_separator { + // If the previous turn inserted non-stream history (exec output, patch status, MCP + // calls), render a separator before starting the next streamed assistant message. + if self.needs_final_message_separator && self.had_work_activity { let elapsed_seconds = self .bottom_pane .status_widget() .map(super::status_indicator_widget::StatusIndicatorWidget::elapsed_seconds); self.add_to_history(history_cell::FinalMessageSeparator::new(elapsed_seconds)); self.needs_final_message_separator = false; + self.had_work_activity = false; + } else if self.needs_final_message_separator { + // Reset the flag even if we don't show separator (no work was done) + self.needs_final_message_separator = false; } self.stream_controller = Some(StreamController::new( self.last_rendered_width.get().map(|w| w.saturating_sub(2)), @@ -1407,6 +1438,8 @@ impl ChatWidget { self.request_redraw(); } } + // Mark that actual work was done (command executed) + self.had_work_activity = true; } pub(crate) fn handle_patch_apply_end_now( @@ -1418,6 +1451,8 @@ impl ChatWidget { if !event.success { self.add_to_history(history_cell::new_patch_apply_failure(event.stderr)); } + // Mark that actual work was done (patch applied) + self.had_work_activity = true; } pub(crate) fn handle_exec_approval_now(&mut self, id: String, ev: ExecApprovalRequestEvent) { @@ -1583,6 +1618,8 @@ impl ChatWidget { if let Some(extra) = extra_cell { self.add_boxed_history(extra); } + // Mark that actual work was done (MCP tool call) + self.had_work_activity = true; } pub(crate) fn new(common: ChatWidgetInit, thread_manager: Arc) -> Self { @@ -1671,6 +1708,7 @@ impl ChatWidget { is_review_mode: false, pre_review_token_info: None, needs_final_message_separator: false, + had_work_activity: false, last_rendered_width: std::cell::Cell::new(None), feedback, current_rollout_path: None, @@ -1768,6 +1806,7 @@ impl ChatWidget { is_review_mode: false, pre_review_token_info: None, needs_final_message_separator: false, + had_work_activity: false, last_rendered_width: std::cell::Cell::new(None), feedback, current_rollout_path: None, @@ -1811,10 +1850,26 @@ impl ChatWidget { modifiers, kind: KeyEventKind::Press, .. - } if c.eq_ignore_ascii_case(&'v') - && modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) => + } if modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) + && c.eq_ignore_ascii_case(&'v') => { - self.paste_image_from_clipboard(); + match paste_image_to_temp_png() { + Ok((path, info)) => { + tracing::debug!( + "pasted image size={}x{} format={}", + info.width, + info.height, + info.encoded_format.label() + ); + self.attach_image(path); + } + Err(err) => { + tracing::warn!("failed to paste image: {err}"); + self.add_to_history(history_cell::new_error_event(format!( + "Failed to paste image: {err}", + ))); + } + } return; } other if other.kind == KeyEventKind::Press => { @@ -1883,32 +1938,6 @@ impl ChatWidget { self.request_redraw(); } - /// Attempt to attach an image from the system clipboard. - /// - /// This is a best-effort path used when we receive an empty paste event, - /// which some terminals emit when the clipboard contains non-text data - /// (like images). When the clipboard can't be read or no image exists, - /// surface a helpful follow-up so the user can retry with a file path. - fn paste_image_from_clipboard(&mut self) { - match paste_image_to_temp_png() { - Ok((path, info)) => { - tracing::debug!( - "pasted image size={}x{} format={}", - info.width, - info.height, - info.encoded_format.label() - ); - self.attach_image(path); - } - Err(err) => { - tracing::warn!("failed to paste image: {err}"); - self.add_to_history(history_cell::new_error_event(format!( - "Failed to paste image: {err}. Try saving the image to a file and pasting the file path instead.", - ))); - } - } - } - pub(crate) fn composer_text_with_pending(&self) -> String { self.bottom_pane.composer_text_with_pending() } @@ -2163,20 +2192,6 @@ impl ChatWidget { self.bottom_pane.handle_paste(text); } - /// Route paste events through image detection. - /// - /// Terminals vary in how they represent paste: some emit an empty paste - /// payload when the clipboard isn't text (common for image-only clipboard - /// contents). Treat the empty payload as a hint to attempt a clipboard - /// image read; otherwise, fall back to text handling. - pub(crate) fn handle_paste_event(&mut self, text: String) { - if text.is_empty() { - self.paste_image_from_clipboard(); - } else { - self.handle_paste(text); - } - } - // Returns true if caller should skip rendering this frame (a future frame is scheduled). pub(crate) fn handle_paste_burst_tick(&mut self, frame_requester: FrameRequester) -> bool { if self.bottom_pane.flush_paste_burst_if_due() { @@ -2444,16 +2459,16 @@ impl ChatWidget { } EventMsg::ExitedReviewMode(review) => self.on_exited_review_mode(review), EventMsg::ContextCompacted(_) => self.on_agent_message("Context compacted".to_owned()), - EventMsg::CollabAgentSpawnBegin(_) - | EventMsg::CollabAgentSpawnEnd(_) - | EventMsg::CollabAgentInteractionBegin(_) - | EventMsg::CollabAgentInteractionEnd(_) - | EventMsg::CollabWaitingBegin(_) - | EventMsg::CollabWaitingEnd(_) - | EventMsg::CollabCloseBegin(_) - | EventMsg::CollabCloseEnd(_) => { - // TODO(jif) handle collab tools. + EventMsg::CollabAgentSpawnBegin(_) => {} + EventMsg::CollabAgentSpawnEnd(ev) => self.on_collab_event(collab::spawn_end(ev)), + EventMsg::CollabAgentInteractionBegin(_) => {} + EventMsg::CollabAgentInteractionEnd(ev) => { + self.on_collab_event(collab::interaction_end(ev)) } + EventMsg::CollabWaitingBegin(ev) => self.on_collab_event(collab::waiting_begin(ev)), + EventMsg::CollabWaitingEnd(ev) => self.on_collab_event(collab::waiting_end(ev)), + EventMsg::CollabCloseBegin(_) => {} + EventMsg::CollabCloseEnd(ev) => self.on_collab_event(collab::close_end(ev)), EventMsg::ThreadRolledBack(_) => {} EventMsg::RawResponseItem(_) | EventMsg::ItemStarted(_) @@ -4579,6 +4594,14 @@ fn skills_for_cwd(cwd: &Path, skills_entries: &[SkillsListEntry]) -> Vec PlainHistoryCell { + let CollabAgentSpawnEndEvent { + call_id, + sender_thread_id, + new_thread_id, + prompt, + status, + } = ev; + let new_agent = new_thread_id + .map(|id| id.to_string()) + .unwrap_or_else(|| "none".to_string()); + let mut details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("new_agent", new_agent), + status_line(&status), + ]; + if let Some(line) = prompt_line(&prompt) { + details.push(line); + } + collab_event("Collab spawn", details) +} + +pub(crate) fn interaction_end(ev: CollabAgentInteractionEndEvent) -> PlainHistoryCell { + let CollabAgentInteractionEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + prompt, + status, + } = ev; + let mut details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + if let Some(line) = prompt_line(&prompt) { + details.push(line); + } + collab_event("Collab send input", details) +} + +pub(crate) fn waiting_begin(ev: CollabWaitingBeginEvent) -> PlainHistoryCell { + let CollabWaitingBeginEvent { + call_id, + sender_thread_id, + receiver_thread_id, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + ]; + collab_event("Collab wait begin", details) +} + +pub(crate) fn waiting_end(ev: CollabWaitingEndEvent) -> PlainHistoryCell { + let CollabWaitingEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + status, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + collab_event("Collab wait end", details) +} + +pub(crate) fn close_end(ev: CollabCloseEndEvent) -> PlainHistoryCell { + let CollabCloseEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + status, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + collab_event("Collab close", details) +} + +fn collab_event(title: impl Into, details: Vec>) -> PlainHistoryCell { + let title = title.into(); + let mut lines: Vec> = vec![vec!["• ".dim(), title.bold()].into()]; + if !details.is_empty() { + lines.extend(prefix_lines(details, " └ ".dim(), " ".into())); + } + PlainHistoryCell::new(lines) +} + +fn detail_line(label: &str, value: impl std::fmt::Display) -> Line<'static> { + Line::from(format!("{label}: {value}").dim()) +} + +fn status_line(status: &AgentStatus) -> Line<'static> { + Line::from(format!("status: {}", status_text(status)).dim()) +} + +fn status_text(status: &AgentStatus) -> &'static str { + match status { + AgentStatus::PendingInit => "pending_init", + AgentStatus::Running => "running", + AgentStatus::Completed(_) => "completed", + AgentStatus::Errored(_) => "errored", + AgentStatus::Shutdown => "shutdown", + AgentStatus::NotFound => "not_found", + } +} + +fn prompt_line(prompt: &str) -> Option> { + let trimmed = prompt.trim(); + if trimmed.is_empty() { + None + } else { + Some(detail_line( + "prompt", + truncate_text(trimmed, COLLAB_PROMPT_PREVIEW_GRAPHEMES), + )) + } +} diff --git a/codex-rs/tui/src/history_cell.rs b/codex-rs/tui/src/history_cell.rs index 8db7be6f66..c060d20cd9 100644 --- a/codex-rs/tui/src/history_cell.rs +++ b/codex-rs/tui/src/history_cell.rs @@ -1358,7 +1358,6 @@ pub(crate) fn new_mcp_tools_output( if tools.is_empty() { lines.push(" • No MCP tools available.".italic().into()); lines.push("".into()); - return PlainHistoryCell { lines }; } let mut servers: Vec<_> = config.mcp_servers.iter().collect(); @@ -1382,6 +1381,9 @@ pub(crate) fn new_mcp_tools_output( header.push(" ".into()); header.push("(disabled)".red()); lines.push(header.into()); + if let Some(reason) = cfg.disabled_reason.as_ref().map(ToString::to_string) { + lines.push(vec![" • Reason: ".into(), reason.dim()].into()); + } lines.push(Line::from("")); continue; } @@ -1664,10 +1666,16 @@ pub(crate) fn new_reasoning_summary_block(full_reasoning_buffer: String) -> Box< } #[derive(Debug)] +/// A visual divider between turns, optionally showing how long the assistant "worked for". +/// +/// This separator is only emitted for turns that performed concrete work (e.g., running commands, +/// applying patches, making MCP tool calls), so purely conversational turns do not show an empty +/// divider. pub struct FinalMessageSeparator { elapsed_seconds: Option, } impl FinalMessageSeparator { + /// Creates a separator; `elapsed_seconds` typically comes from the status indicator timer. pub(crate) fn new(elapsed_seconds: Option) -> Self { Self { elapsed_seconds } } @@ -1836,6 +1844,7 @@ mod tests { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1856,6 +1865,7 @@ mod tests { env_http_headers: Some(env_headers), }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs index 4bae970ee3..29bf2b1ce0 100644 --- a/codex-rs/tui/src/lib.rs +++ b/codex-rs/tui/src/lib.rs @@ -45,6 +45,7 @@ mod bottom_pane; mod chatwidget; mod cli; mod clipboard_paste; +mod collab; mod color; pub mod custom_terminal; mod diff_render; @@ -521,22 +522,22 @@ async fn run_ratatui_app( } } else if cli.resume_last { let provider_filter = vec![config.model_provider_id.clone()]; - match RolloutRecorder::list_threads( + let filter_cwd = if cli.resume_show_all { + None + } else { + Some(config.cwd.as_path()) + }; + match RolloutRecorder::find_latest_thread_path( &config.codex_home, - 1, - None, INTERACTIVE_SESSION_SOURCES, Some(provider_filter.as_slice()), &config.model_provider_id, + filter_cwd, ) .await { - Ok(page) => page - .items - .first() - .map(|it| resume_picker::SessionSelection::Resume(it.path.clone())) - .unwrap_or(resume_picker::SessionSelection::StartFresh), - Err(_) => resume_picker::SessionSelection::StartFresh, + Ok(Some(path)) => resume_picker::SessionSelection::Resume(path), + _ => resume_picker::SessionSelection::StartFresh, } } else if cli.resume_picker { match resume_picker::run_resume_picker( diff --git a/codex-rs/tui2/src/bottom_pane/chat_composer.rs b/codex-rs/tui2/src/bottom_pane/chat_composer.rs index 7cc2dbabf1..c9058e0153 100644 --- a/codex-rs/tui2/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui2/src/bottom_pane/chat_composer.rs @@ -2199,7 +2199,7 @@ impl Renderable for ChatComposer { .unwrap_or("Input disabled.") .to_string() }; - let placeholder = Span::from(text).dim().italic(); + let placeholder = Span::from(text).dim(); Line::from(vec![placeholder]).render_ref(textarea_rect.inner(Margin::new(0, 0)), buf); } } diff --git a/codex-rs/tui2/src/bottom_pane/skill_popup.rs b/codex-rs/tui2/src/bottom_pane/skill_popup.rs index faf386e29c..d4d4a6828f 100644 --- a/codex-rs/tui2/src/bottom_pane/skill_popup.rs +++ b/codex-rs/tui2/src/bottom_pane/skill_popup.rs @@ -87,12 +87,8 @@ impl SkillPopup { .into_iter() .map(|(idx, indices, _score)| { let skill = &self.skills[idx]; - let name = truncate_text(&skill.name, 21); - let description = skill - .short_description - .as_ref() - .unwrap_or(&skill.description) - .clone(); + let name = truncate_text(skill_display_name(skill), 21); + let description = skill_description(skill).to_string(); GenericDisplayRow { name, match_indices: indices, @@ -116,15 +112,20 @@ impl SkillPopup { } for (idx, skill) in self.skills.iter().enumerate() { - if let Some((indices, score)) = fuzzy_match(&skill.name, filter) { + let display_name = skill_display_name(skill); + if let Some((indices, score)) = fuzzy_match(display_name, filter) { out.push((idx, Some(indices), score)); + } else if display_name != skill.name + && let Some((_indices, score)) = fuzzy_match(&skill.name, filter) + { + out.push((idx, None, score)); } } out.sort_by(|a, b| { a.2.cmp(&b.2).then_with(|| { - let an = &self.skills[a.0].name; - let bn = &self.skills[b.0].name; + let an = skill_display_name(&self.skills[a.0]); + let bn = skill_display_name(&self.skills[b.0]); an.cmp(bn) }) }); @@ -176,3 +177,20 @@ fn skill_popup_hint_line() -> Line<'static> { " to close".into(), ]) } + +fn skill_display_name(skill: &SkillMetadata) -> &str { + skill + .interface + .as_ref() + .and_then(|interface| interface.display_name.as_deref()) + .unwrap_or(&skill.name) +} + +fn skill_description(skill: &SkillMetadata) -> &str { + skill + .interface + .as_ref() + .and_then(|interface| interface.short_description.as_deref()) + .or(skill.short_description.as_deref()) + .unwrap_or(&skill.description) +} diff --git a/codex-rs/tui2/src/chatwidget.rs b/codex-rs/tui2/src/chatwidget.rs index 1e38e44835..5facd756f7 100644 --- a/codex-rs/tui2/src/chatwidget.rs +++ b/codex-rs/tui2/src/chatwidget.rs @@ -85,6 +85,7 @@ use codex_core::protocol::ViewImageToolCallEvent; use codex_core::protocol::WarningEvent; use codex_core::protocol::WebSearchBeginEvent; use codex_core::protocol::WebSearchEndEvent; +use codex_core::skills::model::SkillInterface; use codex_core::skills::model::SkillMetadata; use codex_protocol::ThreadId; use codex_protocol::account::PlanType; @@ -128,6 +129,7 @@ use crate::bottom_pane::SelectionViewParams; use crate::bottom_pane::custom_prompt_view::CustomPromptView; use crate::bottom_pane::popup_consts::standard_popup_hint_line; use crate::clipboard_paste::paste_image_to_temp_png; +use crate::collab; use crate::diff_render::display_path_for; use crate::exec_cell::CommandOutput; use crate::exec_cell::ExecCell; @@ -403,8 +405,17 @@ pub(crate) struct ChatWidget { is_review_mode: bool, // Snapshot of token usage to restore after review mode exits. pre_review_token_info: Option>, - // Whether to add a final message separator after the last message + // Whether the next streamed assistant content should be preceded by a final message separator. + // + // This is set whenever we insert a visible history cell that conceptually belongs to a turn. + // The separator itself is only rendered if the turn recorded "work" activity (see + // `had_work_activity`). needs_final_message_separator: bool, + // Whether the current turn performed "work" (exec commands, MCP tool calls, patch applications). + // + // This gates rendering of the "Worked for …" separator so purely conversational turns don't + // show an empty divider. It is reset when the separator is emitted. + had_work_activity: bool, last_rendered_width: std::cell::Cell>, // Feedback sink for /feedback @@ -1021,6 +1032,12 @@ impl ChatWidget { self.add_to_history(history_cell::new_web_search_call(ev.query)); } + fn on_collab_event(&mut self, cell: PlainHistoryCell) { + self.flush_answer_stream_with_separator(); + self.add_to_history(cell); + self.request_redraw(); + } + fn on_get_history_entry_response( &mut self, event: codex_core::protocol::GetHistoryEntryResponseEvent, @@ -1142,14 +1159,20 @@ impl ChatWidget { self.flush_active_cell(); if self.stream_controller.is_none() { - if self.needs_final_message_separator { + // If the previous turn inserted non-stream history (exec output, patch status, MCP + // calls), render a separator before starting the next streamed assistant message. + if self.needs_final_message_separator && self.had_work_activity { let elapsed_seconds = self .bottom_pane .status_widget() .map(super::status_indicator_widget::StatusIndicatorWidget::elapsed_seconds); self.add_to_history(history_cell::FinalMessageSeparator::new(elapsed_seconds)); self.needs_final_message_separator = false; + self.had_work_activity = false; needs_redraw = true; + } else if self.needs_final_message_separator { + // Reset the flag even if we don't show separator (no work was done) + self.needs_final_message_separator = false; } // Streaming must not capture the current viewport width: width-derived wraps are // applied later, at render time, so the transcript can reflow on resize. @@ -1220,6 +1243,8 @@ impl ChatWidget { self.request_redraw(); } } + // Mark that actual work was done (command executed) + self.had_work_activity = true; } pub(crate) fn handle_patch_apply_end_now( @@ -1231,6 +1256,8 @@ impl ChatWidget { if !event.success { self.add_to_history(history_cell::new_patch_apply_failure(event.stderr)); } + // Mark that actual work was done (patch applied) + self.had_work_activity = true; } pub(crate) fn handle_exec_approval_now(&mut self, id: String, ev: ExecApprovalRequestEvent) { @@ -1396,6 +1423,8 @@ impl ChatWidget { if let Some(extra) = extra_cell { self.add_boxed_history(extra); } + // Mark that actual work was done (MCP tool call) + self.had_work_activity = true; } pub(crate) fn new(common: ChatWidgetInit, thread_manager: Arc) -> Self { @@ -1482,6 +1511,7 @@ impl ChatWidget { is_review_mode: false, pre_review_token_info: None, needs_final_message_separator: false, + had_work_activity: false, last_rendered_width: std::cell::Cell::new(None), feedback, current_rollout_path: None, @@ -1577,6 +1607,7 @@ impl ChatWidget { is_review_mode: false, pre_review_token_info: None, needs_final_message_separator: false, + had_work_activity: false, last_rendered_width: std::cell::Cell::new(None), feedback, current_rollout_path: None, @@ -2194,16 +2225,16 @@ impl ChatWidget { } EventMsg::ExitedReviewMode(review) => self.on_exited_review_mode(review), EventMsg::ContextCompacted(_) => self.on_agent_message("Context compacted".to_owned()), - EventMsg::CollabAgentSpawnBegin(_) - | EventMsg::CollabAgentSpawnEnd(_) - | EventMsg::CollabAgentInteractionBegin(_) - | EventMsg::CollabAgentInteractionEnd(_) - | EventMsg::CollabWaitingBegin(_) - | EventMsg::CollabWaitingEnd(_) - | EventMsg::CollabCloseBegin(_) - | EventMsg::CollabCloseEnd(_) => { - // TODO(jif) handle collab tools. + EventMsg::CollabAgentSpawnBegin(_) => {} + EventMsg::CollabAgentSpawnEnd(ev) => self.on_collab_event(collab::spawn_end(ev)), + EventMsg::CollabAgentInteractionBegin(_) => {} + EventMsg::CollabAgentInteractionEnd(ev) => { + self.on_collab_event(collab::interaction_end(ev)) } + EventMsg::CollabWaitingBegin(ev) => self.on_collab_event(collab::waiting_begin(ev)), + EventMsg::CollabWaitingEnd(ev) => self.on_collab_event(collab::waiting_end(ev)), + EventMsg::CollabCloseBegin(_) => {} + EventMsg::CollabCloseEnd(ev) => self.on_collab_event(collab::close_end(ev)), EventMsg::RawResponseItem(_) | EventMsg::ThreadRolledBack(_) | EventMsg::ItemStarted(_) @@ -4296,6 +4327,14 @@ fn skills_for_cwd(cwd: &Path, skills_entries: &[SkillsListEntry]) -> Vec PlainHistoryCell { + let CollabAgentSpawnEndEvent { + call_id, + sender_thread_id, + new_thread_id, + prompt, + status, + } = ev; + let new_agent = new_thread_id + .map(|id| id.to_string()) + .unwrap_or_else(|| "none".to_string()); + let mut details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("new_agent", new_agent), + status_line(&status), + ]; + if let Some(line) = prompt_line(&prompt) { + details.push(line); + } + collab_event("Collab spawn", details) +} + +pub(crate) fn interaction_end(ev: CollabAgentInteractionEndEvent) -> PlainHistoryCell { + let CollabAgentInteractionEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + prompt, + status, + } = ev; + let mut details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + if let Some(line) = prompt_line(&prompt) { + details.push(line); + } + collab_event("Collab send input", details) +} + +pub(crate) fn waiting_begin(ev: CollabWaitingBeginEvent) -> PlainHistoryCell { + let CollabWaitingBeginEvent { + call_id, + sender_thread_id, + receiver_thread_id, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + ]; + collab_event("Collab wait begin", details) +} + +pub(crate) fn waiting_end(ev: CollabWaitingEndEvent) -> PlainHistoryCell { + let CollabWaitingEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + status, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + collab_event("Collab wait end", details) +} + +pub(crate) fn close_end(ev: CollabCloseEndEvent) -> PlainHistoryCell { + let CollabCloseEndEvent { + call_id, + sender_thread_id, + receiver_thread_id, + status, + } = ev; + let details = vec![ + detail_line("call", call_id), + detail_line("sender", sender_thread_id), + detail_line("receiver", receiver_thread_id), + status_line(&status), + ]; + collab_event("Collab close", details) +} + +fn collab_event(title: impl Into, details: Vec>) -> PlainHistoryCell { + let title = title.into(); + let mut lines: Vec> = vec![vec!["• ".dim(), title.bold()].into()]; + if !details.is_empty() { + lines.extend(prefix_lines(details, " └ ".dim(), " ".into())); + } + PlainHistoryCell::new(lines) +} + +fn detail_line(label: &str, value: impl std::fmt::Display) -> Line<'static> { + Line::from(format!("{label}: {value}").dim()) +} + +fn status_line(status: &AgentStatus) -> Line<'static> { + Line::from(format!("status: {}", status_text(status)).dim()) +} + +fn status_text(status: &AgentStatus) -> &'static str { + match status { + AgentStatus::PendingInit => "pending_init", + AgentStatus::Running => "running", + AgentStatus::Completed(_) => "completed", + AgentStatus::Errored(_) => "errored", + AgentStatus::Shutdown => "shutdown", + AgentStatus::NotFound => "not_found", + } +} + +fn prompt_line(prompt: &str) -> Option> { + let trimmed = prompt.trim(); + if trimmed.is_empty() { + None + } else { + Some(detail_line( + "prompt", + truncate_text(trimmed, COLLAB_PROMPT_PREVIEW_GRAPHEMES), + )) + } +} diff --git a/codex-rs/tui2/src/history_cell.rs b/codex-rs/tui2/src/history_cell.rs index dc5ad0ee24..e3334a0681 100644 --- a/codex-rs/tui2/src/history_cell.rs +++ b/codex-rs/tui2/src/history_cell.rs @@ -1422,7 +1422,6 @@ pub(crate) fn new_mcp_tools_output( if tools.is_empty() { lines.push(" • No MCP tools available.".italic().into()); lines.push("".into()); - return PlainHistoryCell { lines }; } let mut servers: Vec<_> = config.mcp_servers.iter().collect(); @@ -1446,6 +1445,9 @@ pub(crate) fn new_mcp_tools_output( header.push(" ".into()); header.push("(disabled)".red()); lines.push(header.into()); + if let Some(reason) = cfg.disabled_reason.as_ref().map(ToString::to_string) { + lines.push(vec![" • Reason: ".into(), reason.dim()].into()); + } lines.push(Line::from("")); continue; } @@ -1734,10 +1736,16 @@ pub(crate) fn new_reasoning_summary_block(full_reasoning_buffer: String) -> Box< } #[derive(Debug)] +/// A visual divider between turns, optionally showing how long the assistant "worked for". +/// +/// This separator is only emitted for turns that performed concrete work (e.g., running commands, +/// applying patches, making MCP tool calls), so purely conversational turns do not show an empty +/// divider. pub struct FinalMessageSeparator { elapsed_seconds: Option, } impl FinalMessageSeparator { + /// Creates a separator; `elapsed_seconds` typically comes from the status indicator timer. pub(crate) fn new(elapsed_seconds: Option) -> Self { Self { elapsed_seconds } } @@ -1971,6 +1979,7 @@ mod tests { cwd: None, }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, @@ -1991,6 +2000,7 @@ mod tests { env_http_headers: Some(env_headers), }, enabled: true, + disabled_reason: None, startup_timeout_sec: None, tool_timeout_sec: None, enabled_tools: None, diff --git a/codex-rs/tui2/src/lib.rs b/codex-rs/tui2/src/lib.rs index ddb38cf29d..55e640c58f 100644 --- a/codex-rs/tui2/src/lib.rs +++ b/codex-rs/tui2/src/lib.rs @@ -46,6 +46,7 @@ mod chatwidget; mod cli; mod clipboard_copy; mod clipboard_paste; +mod collab; mod color; pub mod custom_terminal; mod diff_render; @@ -544,22 +545,22 @@ async fn run_ratatui_app( } } else if cli.resume_last { let provider_filter = vec![config.model_provider_id.clone()]; - match RolloutRecorder::list_threads( + let filter_cwd = if cli.resume_show_all { + None + } else { + Some(config.cwd.as_path()) + }; + match RolloutRecorder::find_latest_thread_path( &config.codex_home, - 1, - None, INTERACTIVE_SESSION_SOURCES, Some(provider_filter.as_slice()), &config.model_provider_id, + filter_cwd, ) .await { - Ok(page) => page - .items - .first() - .map(|it| resume_picker::SessionSelection::Resume(it.path.clone())) - .unwrap_or(resume_picker::SessionSelection::StartFresh), - Err(_) => resume_picker::SessionSelection::StartFresh, + Ok(Some(path)) => resume_picker::SessionSelection::Resume(path), + _ => resume_picker::SessionSelection::StartFresh, } } else if cli.resume_picker { match resume_picker::run_resume_picker(