Refresh Codex provider examples

.codespellignore

@@ -1 +1,2 @@
 iTerm
+trys

.codespellrc

@@ -1,6 +1,6 @@
 [codespell]
 # Ref: https://github.com/codespell-project/codespell#using-a-config-file
-skip = .git*,vendor,*-lock.yaml,*.lock,.codespellrc,*test.ts,*.jsonl,frame*.txt
+skip = .git*,vendor,*-lock.yaml,*.lock,.codespellrc,.codespellignore,*test.ts,*.jsonl,frame*.txt,*/target/*,*/node_modules/*,*/.pnpm-store/*,*/dist/*,*/.yarn/*,package-lock.json,*.map
 check-hidden = true
 ignore-regex = ^\s*"image/\S+": ".*|\b(afterAll)\b
 ignore-words-list = ratatui,ser

.github/workflows/ci.yml

@@ -29,12 +29,13 @@ jobs:
           node-version: 22
 
       - name: Install dependencies
-        run: npm_config_optional=false pnpm install --frozen-lockfile
+        run: pnpm install --frozen-lockfile
 
       # stage_npm_packages.py requires DotSlash when staging releases.
       - uses: facebook/install-dotslash@v2
 
       - name: Stage npm package
+        if: github.repository == 'openai/codex-native'
         id: stage_npm_package
         env:
           GH_TOKEN: ${{ github.token }}
@@ -50,6 +51,7 @@ jobs:
           echo "pack_output=$PACK_OUTPUT" >> "$GITHUB_OUTPUT"
 
       - name: Upload staged npm package artifact
+        if: github.repository == 'openai/codex-native'
         uses: actions/upload-artifact@v5
         with:
           name: codex-npm-staging

.github/workflows/codespell.yml

@@ -8,6 +8,10 @@ on:
   pull_request:
     branches: [main]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

.github/workflows/issue-deduplicator.yml

@@ -6,6 +6,10 @@ on:
       - opened
       - labeled
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+  cancel-in-progress: true
+
 jobs:
   gather-duplicates:
     name: Identify potential duplicates

.github/workflows/issue-labeler.yml

@@ -6,6 +6,10 @@ on:
       - opened
       - labeled
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+  cancel-in-progress: true
+
 jobs:
   gather-labels:
     name: Generate label suggestions

.github/workflows/rust-ci.yml

@@ -6,6 +6,10 @@ on:
       - main
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 # CI builds in debug (dev) for faster signal.
 
 jobs:

.github/workflows/sdk.yml

@@ -29,19 +29,30 @@ jobs:
           cache: pnpm
 
       - uses: dtolnay/rust-toolchain@1.90
+        with:
+          components: rustfmt, clippy
 
       - name: build codex
         run: cargo build --bin codex
         working-directory: codex-rs
 
       - name: Install dependencies
-        run: npm_config_optional=false pnpm install --frozen-lockfile
+        run: pnpm install --frozen-lockfile
 
-      - name: Build SDK packages
+      - name: Build TypeScript SDK packages
         run: pnpm -r --filter ./sdk/typescript run build
 
-      - name: Lint SDK packages
+      - name: Build native SDK package
+        run: pnpm -r --filter ./sdk/native run build
+
+      - name: Lint TypeScript SDK packages
         run: pnpm -r --filter ./sdk/typescript run lint
 
-      - name: Test SDK packages
+      - name: Lint native SDK package
+        run: pnpm -r --filter ./sdk/native run lint
+
+      - name: Test TypeScript SDK packages
         run: pnpm -r --filter ./sdk/typescript run test
+
+      - name: Test native SDK package
+        run: pnpm -r --filter ./sdk/native run test

codex-rs/core/src/tools/registry.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 
 use async_trait::async_trait;
 use codex_protocol::models::ResponseInputItem;
+use tracing::error;
 use tracing::warn;
 
 use crate::client_common::tools::ToolSpec;
@@ -45,19 +46,34 @@ fn pending_external_tools() -> &'static Mutex<Vec<ExternalToolRegistration>> {
 }
 
 pub fn set_pending_external_tools(tools: Vec<ExternalToolRegistration>) {
-    let mut guard = pending_external_tools()
-        .lock()
-        .expect("pending external tools mutex poisoned");
-    *guard = tools;
+    match pending_external_tools().lock() {
+        Ok(mut guard) => {
+            *guard = tools;
+        }
+        Err(err) => {
+            error!(
+                error = ?err,
+                "failed to acquire pending external tools mutex; pending tools unchanged"
+            );
+        }
+    }
 }
 
 pub fn take_pending_external_tools() -> Vec<ExternalToolRegistration> {
-    let mut guard = pending_external_tools()
-        .lock()
-        .expect("pending external tools mutex poisoned");
-    let tools = guard.clone();
-    guard.clear();
-    tools
+    match pending_external_tools().lock() {
+        Ok(mut guard) => {
+            let tools = guard.clone();
+            guard.clear();
+            tools
+        }
+        Err(err) => {
+            error!(
+                error = ?err,
+                "failed to acquire pending external tools mutex; returning empty list"
+            );
+            Vec::new()
+        }
+    }
 }
 
 #[async_trait]
@@ -196,6 +212,12 @@ pub struct ToolRegistryBuilder {
     specs: Vec<ConfiguredToolSpec>,
 }
 
+impl Default for ToolRegistryBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ToolRegistryBuilder {
     pub fn new() -> Self {
         Self {
@@ -217,6 +239,23 @@ impl ToolRegistryBuilder {
             .push(ConfiguredToolSpec::new(spec, supports_parallel_tool_calls));
     }
 
+    pub fn upsert_spec_with_parallel_support(
+        &mut self,
+        spec: ToolSpec,
+        supports_parallel_tool_calls: bool,
+    ) {
+        let spec_name = spec.name().to_string();
+        if let Some(existing) = self
+            .specs
+            .iter_mut()
+            .find(|configured| configured.spec.name() == spec_name)
+        {
+            *existing = ConfiguredToolSpec::new(spec, supports_parallel_tool_calls);
+        } else {
+            self.push_spec_with_parallel_support(spec, supports_parallel_tool_calls);
+        }
+    }
+
     pub fn register_handler(&mut self, name: impl Into<String>, handler: Arc<dyn ToolHandler>) {
         let name = name.into();
         if self

codex-rs/core/src/tools/router.rs

@@ -38,11 +38,11 @@ impl ToolRouter {
     ) -> Self {
         let mut builder = build_specs(config, mcp_tools);
         for tool in external_tools {
-            builder.push_spec_with_parallel_support(
-                tool.spec.clone(),
-                tool.supports_parallel_tool_calls,
-            );
-            builder.register_handler(tool.spec.name(), Arc::clone(&tool.handler));
+            let spec = tool.spec.clone();
+            let supports_parallel = tool.supports_parallel_tool_calls;
+            let spec_name = spec.name().to_string();
+            builder.upsert_spec_with_parallel_support(spec, supports_parallel);
+            builder.register_handler(spec_name, Arc::clone(&tool.handler));
         }
         let (specs, registry) = builder.build();
 
@@ -196,3 +196,90 @@ impl ToolRouter {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client_common::tools::ToolSpec;
+    use crate::features::Features;
+    use crate::model_family::find_family_for_model;
+    use crate::tools::context::ToolOutput;
+    use crate::tools::registry::ExternalToolRegistration;
+    use crate::tools::registry::ToolHandler;
+    use crate::tools::registry::ToolKind;
+    use crate::tools::spec::ToolsConfigParams;
+    use crate::tools::spec::create_function_tool_spec_from_schema;
+    use async_trait::async_trait;
+    use serde_json::json;
+    use std::sync::Arc;
+
+    struct DummyHandler;
+
+    #[async_trait]
+    impl ToolHandler for DummyHandler {
+        fn kind(&self) -> ToolKind {
+            ToolKind::Function
+        }
+
+        async fn handle(
+            &self,
+            _invocation: ToolInvocation,
+        ) -> Result<ToolOutput, FunctionCallError> {
+            Err(FunctionCallError::Fatal("not implemented".to_string()))
+        }
+    }
+
+    #[test]
+    fn external_tool_can_override_builtin_spec() {
+        let model_family = find_family_for_model("codex-mini-latest")
+            .expect("valid model family for codex-mini-latest");
+        let features = Features::with_defaults();
+        let config = ToolsConfig::new(&ToolsConfigParams {
+            model_family: &model_family,
+            features: &features,
+        });
+
+        let custom_spec = create_function_tool_spec_from_schema(
+            "list_mcp_resources".to_string(),
+            Some("custom override".to_string()),
+            json!({
+                "type": "object",
+                "properties": {
+                    "hint": { "type": "string" }
+                },
+                "required": ["hint"],
+                "additionalProperties": false
+            }),
+            true,
+        )
+        .expect("schema converts");
+
+        let external_tools = vec![ExternalToolRegistration {
+            spec: custom_spec,
+            handler: Arc::new(DummyHandler),
+            supports_parallel_tool_calls: false,
+        }];
+
+        let router = ToolRouter::from_config(&config, None, &external_tools);
+        let specs = router.specs();
+
+        let overrides: Vec<_> = specs
+            .iter()
+            .filter(|spec| spec.name() == "list_mcp_resources")
+            .collect();
+        assert_eq!(overrides.len(), 1, "override should replace built-in spec");
+
+        match overrides[0] {
+            ToolSpec::Function(tool) => {
+                assert_eq!(tool.description, "custom override");
+                assert!(tool.strict);
+            }
+            _ => panic!("expected function tool"),
+        }
+
+        assert!(
+            !router.tool_supports_parallel("list_mcp_resources"),
+            "override should control parallel flag"
+        );
+    }
+}

codex-rs/exec/src/event_processor_with_jsonl_output.rs

@@ -20,6 +20,7 @@ use crate::exec_events::McpToolCallItemResult;
 use crate::exec_events::McpToolCallStatus;
 use crate::exec_events::PatchApplyStatus;
 use crate::exec_events::PatchChangeKind;
+use crate::exec_events::RawEvent;
 use crate::exec_events::ReasoningItem;
 use crate::exec_events::ThreadErrorEvent;
 use crate::exec_events::ThreadEvent;
@@ -107,7 +108,7 @@ impl EventProcessorWithJsonOutput {
     }
 
     pub fn collect_thread_events(&mut self, event: &Event) -> Vec<ThreadEvent> {
-        match &event.msg {
+        let mut events = match &event.msg {
             EventMsg::SessionConfigured(ev) => self.handle_session_configured(ev),
             EventMsg::AgentMessage(ev) => self.handle_agent_message(ev),
             EventMsg::AgentReasoning(ev) => self.handle_reasoning_event(ev),
@@ -148,7 +149,15 @@ impl EventProcessorWithJsonOutput {
             })],
             EventMsg::PlanUpdate(ev) => self.handle_plan_update(ev),
             _ => Vec::new(),
+        };
+
+        if events.is_empty()
+            && let Ok(raw) = serde_json::to_value(&event.msg)
+        {
+            events.push(ThreadEvent::Raw(RawEvent { raw }));
         }
+
+        events
     }
 
     fn get_next_item_id(&self) -> String {