chore(event_mapping) handle new ide context format

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

@@ -1379,6 +1379,9 @@ pub enum TurnStatus {
 pub struct TurnStartParams {
     pub thread_id: String,
     pub input: Vec<UserInput>,
+    /// Helpful information about the user's IDE state. Use judiciously to provide the model with
+    /// useful context.
+    pub user_ide_context: Option<String>,
     /// Override the working directory for this turn and subsequent turns.
     pub cwd: Option<PathBuf>,
     /// Override the approval policy for this turn and subsequent turns.

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

@@ -131,7 +131,9 @@ use codex_core::find_thread_path_by_id_str;
 use codex_core::git_info::git_diff_to_remote;
 use codex_core::mcp::collect_mcp_snapshot;
 use codex_core::mcp::group_tools_by_server;
+use codex_core::normalize_user_ide_context;
 use codex_core::parse_cursor;
+use codex_core::prepend_user_ide_context;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::Op;
 use codex_core::protocol::ReviewDelivery as CoreReviewDelivery;
@@ -1604,6 +1606,7 @@ impl CodexMessageProcessor {
             config: request_overrides,
             base_instructions,
             developer_instructions,
+            ..
         } = params;
 
         let overrides_requested = model.is_some()
@@ -2744,12 +2747,17 @@ impl CodexMessageProcessor {
         };
 
         // Map v2 input items to core input items.
-        let mapped_items: Vec<CoreInputItem> = params
+        let mut mapped_items: Vec<CoreInputItem> = params
             .input
             .into_iter()
             .map(V2UserInput::into_core)
             .collect();
 
+        if let Some(user_ide_context) = params.user_ide_context.and_then(normalize_user_ide_context)
+        {
+            prepend_user_ide_context(&mut mapped_items, &user_ide_context);
+        }
+
         let has_any_overrides = params.cwd.is_some()
             || params.approval_policy.is_some()
             || params.sandbox_policy.is_some()

codex-rs/app-server/tests/suite/v2/turn_start.rs

@@ -35,12 +35,22 @@ use codex_core::protocol_config_types::ReasoningSummary;
 use codex_protocol::openai_models::ReasoningEffort;
 use core_test_support::skip_if_no_network;
 use pretty_assertions::assert_eq;
+use serde_json::Value;
 use std::path::Path;
 use tempfile::TempDir;
 use tokio::time::timeout;
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
+fn value_contains_str(value: &Value, needle: &str) -> bool {
+    match value {
+        Value::Null | Value::Bool(_) | Value::Number(_) => false,
+        Value::String(s) => s.contains(needle),
+        Value::Array(values) => values.iter().any(|v| value_contains_str(v, needle)),
+        Value::Object(map) => map.values().any(|v| value_contains_str(v, needle)),
+    }
+}
+
 #[tokio::test]
 async fn turn_start_emits_notifications_and_accepts_model_override() -> Result<()> {
     // Provide a mock server and config so model wiring is valid.
@@ -148,6 +158,71 @@ async fn turn_start_emits_notifications_and_accepts_model_override() -> Result<(
     Ok(())
 }
 
+#[tokio::test]
+async fn turn_start_includes_user_ide_context_in_model_request() -> Result<()> {
+    let user_ide_context = "some ide context";
+    let tagged = format!("<user_ide_context>{user_ide_context}</user_ide_context>");
+
+    // Two Codex turns hit the mock model (session start + turn/start).
+    let responses = vec![
+        create_final_assistant_message_sse_response("Done")?,
+        create_final_assistant_message_sse_response("Done")?,
+    ];
+    let server = create_mock_chat_completions_server_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::<ThreadStartResponse>(thread_resp)?;
+
+    let turn_req = mcp
+        .send_turn_start_request(TurnStartParams {
+            thread_id: thread.id.clone(),
+            input: vec![V2UserInput::Text {
+                text: "Hello".to_string(),
+            }],
+            user_ide_context: Some(user_ide_context.to_string()),
+            ..Default::default()
+        })
+        .await?;
+    timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
+    )
+    .await??;
+    timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_notification_message("turn/completed"),
+    )
+    .await??;
+
+    let requests = server.received_requests().await.expect("received requests");
+    assert!(
+        requests.iter().any(|request| {
+            request
+                .body_json::<Value>()
+                .is_ok_and(|body| value_contains_str(&body, &tagged))
+        }),
+        "expected request body to contain tagged user_ide_context"
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn turn_start_accepts_local_image_input() -> Result<()> {
     // Two Codex turns hit the mock model (session start + turn/start).
@@ -530,6 +605,7 @@ async fn turn_start_updates_sandbox_and_cwd_between_turns_v2() -> Result<()> {
             input: vec![V2UserInput::Text {
                 text: "first turn".to_string(),
             }],
+            user_ide_context: None,
             cwd: Some(first_cwd.clone()),
             approval_policy: Some(codex_app_server_protocol::AskForApproval::Never),
             sandbox_policy: Some(codex_app_server_protocol::SandboxPolicy::WorkspaceWrite {
@@ -562,6 +638,7 @@ async fn turn_start_updates_sandbox_and_cwd_between_turns_v2() -> Result<()> {
             input: vec![V2UserInput::Text {
                 text: "second turn".to_string(),
             }],
+            user_ide_context: None,
             cwd: Some(second_cwd.clone()),
             approval_policy: Some(codex_app_server_protocol::AskForApproval::Never),
             sandbox_policy: Some(codex_app_server_protocol::SandboxPolicy::DangerFullAccess),

codex-rs/core/src/environment_context.rs

@@ -8,11 +8,40 @@ use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG;
 use codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG;
+use codex_protocol::protocol::USER_IDE_CONTEXT_CLOSE_TAG;
+use codex_protocol::protocol::USER_IDE_CONTEXT_OPEN_TAG;
+use codex_protocol::user_input::UserInput;
 use codex_utils_absolute_path::AbsolutePathBuf;
 use serde::Deserialize;
 use serde::Serialize;
 use std::path::PathBuf;
 
+pub(crate) fn is_user_ide_context(text: &str) -> bool {
+    text.starts_with(USER_IDE_CONTEXT_OPEN_TAG) && text.ends_with(USER_IDE_CONTEXT_CLOSE_TAG)
+}
+
+pub fn normalize_user_ide_context(user_ide_context: String) -> Option<String> {
+    let trimmed = user_ide_context.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+pub fn prepend_user_ide_context(items: &mut Vec<UserInput>, user_ide_context: &str) {
+    // Bundle IDE context as its own content item so downstream request builders can place it
+    // into the model input while core can still filter it from user-visible turn items.
+    items.insert(
+        0,
+        UserInput::Text {
+            text: format!(
+                "{USER_IDE_CONTEXT_OPEN_TAG}{user_ide_context}{USER_IDE_CONTEXT_CLOSE_TAG}"
+            ),
+        },
+    );
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(rename = "environment_context", rename_all = "snake_case")]
 pub(crate) struct EnvironmentContext {
@@ -210,6 +239,36 @@ mod tests {
         }
     }
 
+    #[test]
+    fn normalize_user_ide_context_trims_and_drops_empty() {
+        assert_eq!(
+            normalize_user_ide_context("  some context \n".to_string()),
+            Some("some context".to_string())
+        );
+        assert_eq!(normalize_user_ide_context("   \n\t".to_string()), None);
+    }
+
+    #[test]
+    fn prepend_user_ide_context_inserts_tagged_text_first() {
+        let mut items = vec![UserInput::Text {
+            text: "Hello world".to_string(),
+        }];
+
+        prepend_user_ide_context(&mut items, "ctx");
+
+        assert_eq!(
+            items,
+            vec![
+                UserInput::Text {
+                    text: "<user_ide_context>ctx</user_ide_context>".to_string(),
+                },
+                UserInput::Text {
+                    text: "Hello world".to_string(),
+                },
+            ]
+        );
+    }
+
     #[test]
     fn serialize_workspace_write_environment_context() {
         let cwd = test_path_buf("/repo");