claude-code-rust 0.11.2 → 0.12.0

package/README.md

@@ -35,6 +35,13 @@ If `claude-rs` resolves to an older global shim, ensure your npm global bin dire
 claude-rs
 ```
 
+> [!WARNING]
+> **Agent SDK billing changes on June 15, 2026.** Anthropic says Agent SDK usage, `claude -p`, Claude Code GitHub Actions, and third-party Agent SDK apps will use a separate monthly Agent SDK credit instead of normal interactive Claude or Claude Code subscription limits. Because Claude Code Rust wraps the Agent SDK, treat usage through this project as Agent SDK usage. If that credit is exhausted, continued use may require enabling extra usage billed at standard API rates, or requests may pause until the credit refreshes.
+>
+> Sources:
+> - [Anthropic support: Use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan)
+> - [ClaudeDevs announcement](https://x.com/ClaudeDevs/status/2054610152817619388)
+
 ## Why
 
 The stock Claude Code TUI runs on Node.js with React Ink. This causes real problems:
@@ -47,15 +54,14 @@ The stock Claude Code TUI runs on Node.js with React Ink. This causes real probl
 
 Claude Code Rust fixes all of these by compiling to a single native binary with direct terminal control via Crossterm.
 
-## Architecture
-
-Three-layer design:
-
-**Presentation** (Rust/Ratatui) - Single binary with an async event loop (Tokio) handling keyboard input and bridge client events concurrently. Virtual-scrolled chat history with syntax-highlighted code blocks.
+## Custom Commands
 
-**Agent SDK Bridge** (stdio JSON envelopes) - Spawns `agent-sdk/dist/bridge.js` as a child process and communicates via line-delimited JSON envelopes over stdin/stdout. Bidirectional streaming for user messages, tool updates, and permission requests.
+Claude Code Rust adds project-local slash commands that set environment variables via `.claude/settings.local.json` without leaving the TUI. Changes apply on the next session.
 
-**Agent Runtime** (Anthropic Agent SDK) - The TypeScript bridge drives `@anthropic-ai/claude-agent-sdk`, which manages authentication, session/query lifecycle, and tool execution.
+| Command | Usage | Description |
+|---------|-------|-------------|
+| `/1m-context` | `/1m-context <enable\|disable\|status>` | Disable the 1 million token context window to improve model performance and prevent quality degradation on large context windows. |
+| `/opus-version` | `/opus-version <4.5\|4.6\|4.7\|default\|status>` | Pin the Opus model version for the current folder. Useful for switching to 4.6 or 4.5 to avoid 4.7's tokenization issues. Use `default` to clear the pin. |
 
 ## Status
 
@@ -75,7 +81,7 @@ This project is not affiliated with, endorsed by, or supported by Anthropic.
 
 A quick note on where this project stands, since I know people worry about this kind of thing: claude-code-rust is a terminal UI that I wrote from scratch in Rust. It is not a fork, copy or port of the latest Claude Code source leak -- it talks to Anthropic's official [Agent SDK](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/agent-sdk) as a runtime dependency instead, the same way any other third-party tool would. No Anthropic source code was read or used as reference at any point during development.
 
-The project uses your existing Claude Code subscription via the Agent SDK and the Agent SDK's terms allow building on top of it. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
+The project authenticates through your existing Claude Code account via the Agent SDK, and the Agent SDK's terms allow building on top of it. Billing, credits, limits, and overage behavior are controlled by Anthropic, including the Agent SDK credit change noted above. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
 
 This project's source code is licensed under [Apache-2.0](LICENSE). The Agent SDK itself is proprietary and governed by [Anthropic's Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms).
 

package/agent-sdk/dist/bridge/history.js

@@ -1,5 +1,5 @@
 import { asRecordOrNull } from "./shared.js";
-import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
+import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolSearchToolName, isToolSearchToolResultType, isToolUseBlockType, } from "./tooling.js";
 function nonEmptyTrimmed(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -29,23 +29,32 @@ function pushResumeTextChunk(updates, role, text) {
     }
     updates.push({ type: "user_message_chunk", content: { type: "text", text } });
 }
-function pushResumeToolUse(updates, toolCalls, block, parentToolUseId) {
+function pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId) {
     const toolUseId = typeof block.id === "string" ? block.id : "";
     if (!toolUseId) {
         return;
     }
     const name = typeof block.name === "string" ? block.name : "Tool";
     const input = asRecordOrNull(block.input) ?? {};
+    if (isToolSearchToolName(name)) {
+        hiddenToolUseIds.add(toolUseId);
+        return;
+    }
     const toolCall = createToolCall(toolUseId, name, input, parentToolUseId);
     toolCall.status = "in_progress";
     toolCalls.set(toolUseId, toolCall);
     updates.push({ type: "tool_call", tool_call: toolCall });
 }
-function pushResumeToolResult(updates, toolCalls, block) {
+function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block) {
     const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
     if (!toolUseId) {
         return;
     }
+    const blockType = typeof block.type === "string" ? block.type : "";
+    if (isToolSearchToolResultType(blockType) || hiddenToolUseIds.has(toolUseId)) {
+        hiddenToolUseIds.add(toolUseId);
+        return;
+    }
     const isError = Boolean(block.is_error);
     const base = toolCalls.get(toolUseId);
     const fields = buildToolResultFields(isError, block.content, base, block);
@@ -101,6 +110,7 @@ export function mapSdkSessions(infos, limit = 50) {
 export function mapSessionMessagesToUpdates(messages) {
     const updates = [];
     const toolCalls = new Map();
+    const hiddenToolUseIds = new Set();
     for (const entry of messages) {
         const fallbackRole = entry.type === "assistant" ? "assistant" : "user";
         for (const message of messageCandidates(entry.message)) {
@@ -126,11 +136,11 @@ export function mapSessionMessagesToUpdates(messages) {
                     continue;
                 }
                 if (isToolUseBlockType(blockType) && role === "assistant") {
-                    pushResumeToolUse(updates, toolCalls, block, parentToolUseId);
+                    pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId);
                     continue;
                 }
                 if (TOOL_RESULT_TYPES.has(blockType)) {
-                    pushResumeToolResult(updates, toolCalls, block);
+                    pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block);
                     continue;
                 }
                 if (blockType === "image") {

package/agent-sdk/dist/bridge/message_handlers.js

@@ -1,8 +1,8 @@
 import { asRecordOrNull } from "./shared.js";
 import { toPermissionMode, buildModeState, refreshSupportedModesForSession } from "./commands.js";
 import { writeEvent, emitSessionUpdate, emitConnectEvent, emitSessionReplacedEvent, } from "./events.js";
-import { TOOL_RESULT_TYPES, unwrapToolUseResult } from "./tooling.js";
-import { emitToolCall, emitToolCallUpdate, emitPlanIfTodoWrite, emitToolResultUpdate, finalizeOpenToolCalls, emitToolProgressUpdate, emitToolSummaryUpdate, ensureToolCallVisible, resolveTaskToolUseId, taskProgressText, taskUpdatedFields, } from "./tool_calls.js";
+import { TOOL_RESULT_TYPES, isToolSearchToolName, isToolSearchToolResultType, unwrapToolUseResult, } from "./tooling.js";
+import { emitToolCall, emitToolCallUpdate, emitPlanIfTodoWrite, emitToolResultUpdate, finalizeOpenToolCalls, emitToolProgressUpdate, emitToolSummaryUpdate, ensureToolCallVisible, resolveTaskToolUseId, toolAcceptsTaskLifecycle, taskProgressText, taskUpdatedFields, } from "./tool_calls.js";
 import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdateIfChanged } from "./error_classification.js";
 import { mapAvailableAgentsFromNames, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { buildApiRetryUpdate, buildRateLimitUpdate, normalizeSettingsParseErrors, numberField, parseRuntimeSessionState, } from "./state_parsing.js";
@@ -155,6 +155,12 @@ export function handleTaskSystemMessage(session, subtype, msg) {
         return;
     }
     const toolCall = ensureToolCallVisible(session, toolUseId, "Agent", {});
+    if (!toolAcceptsTaskLifecycle(toolCall)) {
+        if (taskId) {
+            session.taskToolUseIds.delete(taskId);
+        }
+        return;
+    }
     if (toolCall.status === "pending") {
         emitToolCallUpdate(session, toolUseId, { status: "in_progress" }, "progress");
     }
@@ -238,6 +244,31 @@ function logContentBlockLinkage(session, blockType, toolUseId, toolName, linkage
         },
     });
 }
+function hideToolUse(session, toolUseId) {
+    if (toolUseId) {
+        session.hiddenToolUseIds.add(toolUseId);
+    }
+}
+function isHiddenToolUse(session, toolUseId, toolName) {
+    if (!toolUseId) {
+        return false;
+    }
+    if (isToolSearchToolName(toolName)) {
+        hideToolUse(session, toolUseId);
+        return true;
+    }
+    return session.hiddenToolUseIds.has(toolUseId);
+}
+function isHiddenToolResult(session, toolUseId, blockType) {
+    if (!toolUseId) {
+        return false;
+    }
+    if (isToolSearchToolResultType(blockType)) {
+        hideToolUse(session, toolUseId);
+        return true;
+    }
+    return session.hiddenToolUseIds.has(toolUseId);
+}
 export function handleContentBlock(session, block, linkage) {
     const blockType = typeof block.type === "string" ? block.type : "";
     if (blockType === "text") {
@@ -261,6 +292,9 @@ export function handleContentBlock(session, block, linkage) {
         if (!toolUseId) {
             return;
         }
+        if (isHiddenToolUse(session, toolUseId, name)) {
+            return;
+        }
         logContentBlockLinkage(session, blockType, toolUseId, name, linkage);
         emitPlanIfTodoWrite(session, name, input);
         emitToolCall(session, toolUseId, name, input, linkage?.parentToolUseId ?? null);
@@ -271,6 +305,9 @@ export function handleContentBlock(session, block, linkage) {
         if (!toolUseId) {
             return;
         }
+        if (isHiddenToolResult(session, toolUseId, blockType)) {
+            return;
+        }
         logContentBlockLinkage(session, blockType, toolUseId, undefined, linkage);
         const isError = Boolean(block.is_error);
         emitToolResultUpdate(session, toolUseId, isError, block.content, block);
@@ -594,6 +631,9 @@ export function handleSdkMessage(session, message) {
     if (type === "tool_progress") {
         const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
         const toolName = typeof msg.tool_name === "string" ? msg.tool_name : "Tool";
+        if (isHiddenToolUse(session, toolUseId, toolName)) {
+            return;
+        }
         bridgeLogger.debug({
             target: LOG_TARGETS.APP_TOOL,
             eventName: "sdk_tool_progress_linkage_observed",
@@ -620,6 +660,9 @@ export function handleSdkMessage(session, message) {
             : [];
         if (summary && toolIds.length > 0) {
             for (const toolUseId of toolIds) {
+                if (session.hiddenToolUseIds.has(toolUseId)) {
+                    continue;
+                }
                 emitToolSummaryUpdate(session, toolUseId, summary);
             }
         }
@@ -672,6 +715,9 @@ export function handleSdkMessage(session, message) {
         handleUserToolResultBlocks(session, msg);
         const toolUseId = typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : "";
         if (toolUseId && "tool_use_result" in msg) {
+            if (session.hiddenToolUseIds.has(toolUseId)) {
+                return;
+            }
             const parsed = unwrapToolUseResult(msg.tool_use_result);
             emitToolResultUpdate(session, toolUseId, parsed.isError, parsed.content, msg.tool_use_result);
         }

package/agent-sdk/dist/bridge/session_lifecycle.js

@@ -7,9 +7,13 @@ import { AsyncQueue } from "./shared.js";
 import { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
 import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, } from "./events.js";
 import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.js";
+import { isToolSearchToolName } from "./tooling.js";
 import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
 import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+const BRIDGE_RUNTIME_PROCESS_NAME = process.platform === "win32" ? "claude-rs-bridge-node.exe" : "claude-rs-bridge-node";
+const BRIDGE_RUNTIME_GUARD_PROMPT = `Do not terminate the Claude Rust bridge runtime process \`${BRIDGE_RUNTIME_PROCESS_NAME}\`; ` +
+    "when cleaning up development servers, only stop processes by explicit PIDs you started in this session.";
 function permissionDisplayFromCanUseOptions(options) {
     const title = typeof options.title === "string" ? options.title.trim() : "";
     const displayName = typeof options.displayName === "string" ? options.displayName.trim() : "";
@@ -218,6 +222,10 @@ export async function createSession(params) {
     const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
         const toolUseId = options.toolUseID;
+        if (isToolSearchToolName(toolName)) {
+            session?.hiddenToolUseIds.add(toolUseId);
+            return { behavior: "allow", updatedInput: inputData, toolUseID: toolUseId };
+        }
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
             const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
             return await requestExitPlanModeApproval(session, toolUseId, inputData, existing);
@@ -340,6 +348,7 @@ export async function createSession(params) {
         pendingQuestions: new Map(),
         pendingElicitations: new Map(),
         mcpStatusRevalidatedAt: new Map(),
+        hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
@@ -578,14 +587,15 @@ function startupPermissionModeOptions(launchSettings) {
 }
 function systemPromptFromLaunchSettings(launchSettings) {
     const language = launchSettings.language?.trim();
-    if (!language) {
-        return undefined;
+    const appendLines = [BRIDGE_RUNTIME_GUARD_PROMPT];
+    if (language) {
+        appendLines.push(`Always respond to the user in ${language} unless the user explicitly asks for a different language. ` +
+            `Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.`);
     }
     return {
         type: "preset",
         preset: "claude_code",
-        append: `Always respond to the user in ${language} unless the user explicitly asks for a different language. ` +
-            `Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.`,
+        append: appendLines.join(" "),
     };
 }
 export function buildQueryOptions(params) {
@@ -603,7 +613,7 @@ export function buildQueryOptions(params) {
         ...modelOption,
         ...permissionModeOptions,
         toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
-        ...(systemPrompt ? { systemPrompt } : {}),
+        systemPrompt,
         ...(params.launchSettings.agent_progress_summaries !== undefined
             ? { agentProgressSummaries: params.launchSettings.agent_progress_summaries }
             : {}),

package/agent-sdk/dist/bridge/state_parsing.js

@@ -8,6 +8,13 @@ export function numberField(record, ...keys) {
     }
     return undefined;
 }
+function nonNegativeNumberField(record, ...keys) {
+    const value = numberField(record, ...keys);
+    if (value === undefined || value < 0) {
+        return undefined;
+    }
+    return value;
+}
 export function parseFastModeState(value) {
     if (value === "off" || value === "cooldown" || value === "on") {
         return value;
@@ -86,7 +93,7 @@ export function buildRateLimitUpdate(rateLimitInfo) {
 export function buildApiRetryUpdate(message) {
     const attempt = numberField(message, "attempt");
     const maxRetries = numberField(message, "max_retries", "maxRetries");
-    const retryDelayMs = numberField(message, "retry_delay_ms", "retryDelayMs");
+    const retryDelayMs = nonNegativeNumberField(message, "retry_delay_ms", "retryDelayMs");
     if (attempt === undefined || maxRetries === undefined || retryDelayMs === undefined) {
         return null;
     }

package/agent-sdk/dist/bridge/tool_calls.js

@@ -1,6 +1,8 @@
 import { emitSessionUpdate } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { buildToolResultFields, createToolCall } from "./tooling.js";
+const TOOL_SUMMARY_TOOL_NAMES = new Set(["Agent", "Task", "WebSearch", "WebFetch", "ExitPlanMode"]);
+const TASK_LIFECYCLE_TOOL_NAMES = new Set(["Agent", "Task"]);
 function jsonSize(value) {
     if (value === undefined) {
         return undefined;
@@ -30,6 +32,14 @@ function toolName(base, fields) {
     }
     return toolNameFromMeta(base?.meta);
 }
+export function toolUsesSummaryOutput(base) {
+    const baseToolName = toolName(base);
+    return Boolean(baseToolName && TOOL_SUMMARY_TOOL_NAMES.has(baseToolName));
+}
+export function toolAcceptsTaskLifecycle(base) {
+    const baseToolName = toolName(base);
+    return Boolean(baseToolName && TASK_LIFECYCLE_TOOL_NAMES.has(baseToolName));
+}
 function classifyFailureKind(rawOutput) {
     if (!rawOutput) {
         return "failed";
@@ -279,6 +289,9 @@ export function emitToolSummaryUpdate(session, toolUseId, summary) {
     if (!base) {
         return;
     }
+    if (!toolUsesSummaryOutput(base)) {
+        return;
+    }
     const fields = {
         status: base.status === "failed" || base.status === "killed" ? base.status : "completed",
         raw_output: summary,

package/agent-sdk/dist/bridge/tooling.js

@@ -10,6 +10,13 @@ export const TOOL_RESULT_TYPES = new Set([
     "text_editor_code_execution_tool_result",
     "mcp_tool_result",
 ]);
+export function isToolSearchToolName(name) {
+    const normalized = name.replace(/[\s_-]+/g, "").toLowerCase();
+    return normalized === "toolsearch" || normalized === "toolsearchtool";
+}
+export function isToolSearchToolResultType(blockType) {
+    return blockType === "tool_search_tool_result";
+}
 export function isToolUseBlockType(blockType) {
     return blockType === "tool_use" || blockType === "server_tool_use" || blockType === "mcp_tool_use";
 }

package/agent-sdk/dist/bridge.js

@@ -43,7 +43,7 @@ export async function generatePersistedSessionTitle(query, description) {
     }
     return title;
 }
-const EXPECTED_AGENT_SDK_VERSION = "0.2.112";
+const EXPECTED_AGENT_SDK_VERSION = "0.3.146";
 const require = createRequire(import.meta.url);
 export function resolveInstalledAgentSdkVersion() {
     try {

package/agent-sdk/dist/bridge.test.js

@@ -6,6 +6,11 @@ import { emitCurrentModelUpdate, refreshCurrentModel, resolveCurrentModel, shoul
 import { emitToolProgressUpdate } from "./bridge/tool_calls.js";
 import { requestAskUserQuestionAnswers } from "./bridge/user_interaction.js";
 import { handleResultMessage } from "./bridge/message_handlers.js";
+const BRIDGE_RUNTIME_PROCESS_NAME = process.platform === "win32" ? "claude-rs-bridge-node.exe" : "claude-rs-bridge-node";
+const BRIDGE_RUNTIME_GUARD_PROMPT = `Do not terminate the Claude Rust bridge runtime process \`${BRIDGE_RUNTIME_PROCESS_NAME}\`; ` +
+    "when cleaning up development servers, only stop processes by explicit PIDs you started in this session.";
+const GERMAN_LANGUAGE_PROMPT = "Always respond to the user in German unless the user explicitly asks for a different language. " +
+    "Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.";
 function makeSessionState() {
     const input = new AsyncQueue();
     return {
@@ -28,6 +33,7 @@ function makeSessionState() {
         pendingQuestions: new Map(),
         pendingElicitations: new Map(),
         mcpStatusRevalidatedAt: new Map(),
+        hiddenToolUseIds: new Set(),
         authHintSent: false,
     };
 }
@@ -425,8 +431,7 @@ test("buildQueryOptions maps launch settings into sdk query options", () => {
     assert.deepEqual(options.systemPrompt, {
         type: "preset",
         preset: "claude_code",
-        append: "Always respond to the user in German unless the user explicitly asks for a different language. " +
-            "Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.",
+        append: `${BRIDGE_RUNTIME_GUARD_PROMPT} ${GERMAN_LANGUAGE_PROMPT}`,
     });
     assert.equal(options.model, "haiku");
     assert.equal(options.permissionMode, "plan");
@@ -536,7 +541,7 @@ test("buildQueryOptions enables dangerous skip flag for bypass permissions start
     assert.equal(options.permissionMode, "bypassPermissions");
     assert.equal(options.allowDangerouslySkipPermissions, true);
 });
-test("buildQueryOptions omits startup overrides for default logout path", () => {
+test("buildQueryOptions omits optional startup overrides but keeps bridge guard prompt", () => {
     const input = new AsyncQueue();
     const options = buildQueryOptions({
         cwd: "C:/work",
@@ -551,7 +556,11 @@ test("buildQueryOptions omits startup overrides for default logout path", () =>
     assert.equal("model" in options, false);
     assert.equal("permissionMode" in options, false);
     assert.equal("allowDangerouslySkipPermissions" in options, false);
-    assert.equal("systemPrompt" in options, false);
+    assert.deepEqual(options.systemPrompt, {
+        type: "preset",
+        preset: "claude_code",
+        append: BRIDGE_RUNTIME_GUARD_PROMPT,
+    });
     assert.equal("agentProgressSummaries" in options, false);
 });
 test("buildQueryOptions makes sandbox fallback explicit when enabled", () => {
@@ -714,6 +723,161 @@ test("handleTaskSystemMessage final summary replaces prior task content and fina
     });
     assert.equal(session.taskToolUseIds.has("task-1"), false);
 });
+test("handleTaskSystemMessage ignores lifecycle content for concrete output tools", () => {
+    const session = makeSessionState();
+    const protectedTools = [
+        createToolCall("tool-bash", "Bash", { command: "git status" }),
+        createToolCall("tool-read", "Read", { file_path: "src/main.rs" }),
+        createToolCall("tool-write", "Write", {
+            file_path: "src/main.rs",
+            content: "updated file contents",
+        }),
+    ];
+    for (const toolCall of protectedTools) {
+        toolCall.status = "in_progress";
+        toolCall.raw_output = `actual output for ${toolCall.tool_call_id}`;
+        session.toolCalls.set(toolCall.tool_call_id, toolCall);
+    }
+    const events = captureBridgeEvents(() => {
+        for (const toolCall of protectedTools) {
+            const taskId = `task-${toolCall.tool_call_id}`;
+            handleTaskSystemMessage(session, "task_started", {
+                task_id: taskId,
+                tool_use_id: toolCall.tool_call_id,
+                description: "Show working tree status",
+            });
+            handleTaskSystemMessage(session, "task_notification", {
+                task_id: taskId,
+                tool_use_id: toolCall.tool_call_id,
+                status: "completed",
+                summary: "Show diff summary for unstaged changes",
+            });
+        }
+    });
+    assert.deepEqual(events, []);
+    for (const toolCall of protectedTools) {
+        const stored = session.toolCalls.get(toolCall.tool_call_id);
+        assert.equal(stored?.status, "in_progress");
+        assert.equal(stored?.raw_output, `actual output for ${toolCall.tool_call_id}`);
+    }
+});
+test("handleSdkMessage ignores tool_use_summary for Bash Read and Write tools", () => {
+    const session = makeSessionState();
+    const protectedTools = [
+        createToolCall("tool-bash", "Bash", { command: "git diff" }),
+        createToolCall("tool-read", "Read", { file_path: "src/main.rs" }),
+        createToolCall("tool-write", "Write", {
+            file_path: "src/main.rs",
+            content: "updated file contents",
+        }),
+    ];
+    for (const toolCall of protectedTools) {
+        toolCall.status = "completed";
+        toolCall.raw_output = `actual output for ${toolCall.tool_call_id}`;
+        session.toolCalls.set(toolCall.tool_call_id, toolCall);
+    }
+    const events = captureBridgeEvents(() => {
+        handleSdkMessage(session, {
+            type: "tool_use_summary",
+            summary: "Show commits on this branch since diverging from main",
+            preceding_tool_use_ids: protectedTools.map((toolCall) => toolCall.tool_call_id),
+            uuid: "message-summary",
+            session_id: "session-1",
+        });
+    });
+    assert.deepEqual(events, []);
+    for (const toolCall of protectedTools) {
+        assert.equal(session.toolCalls.get(toolCall.tool_call_id)?.raw_output, `actual output for ${toolCall.tool_call_id}`);
+    }
+});
+test("handleSdkMessage applies tool_use_summary for summary-oriented tools", () => {
+    const session = makeSessionState();
+    const toolCall = createToolCall("tool-agent", "Agent", { prompt: "Inspect auth flow" });
+    session.toolCalls.set(toolCall.tool_call_id, toolCall);
+    const events = captureBridgeEvents(() => {
+        handleSdkMessage(session, {
+            type: "tool_use_summary",
+            summary: "Inspected auth flow and found the failing check",
+            preceding_tool_use_ids: [toolCall.tool_call_id],
+            uuid: "message-summary",
+            session_id: "session-1",
+        });
+    });
+    const lastEvent = events.at(-1);
+    assert.ok(lastEvent);
+    assert.equal(lastEvent.event, "session_update");
+    assert.deepEqual(lastEvent.update, {
+        type: "tool_call_update",
+        tool_call_update: {
+            tool_call_id: "tool-agent",
+            fields: {
+                status: "completed",
+                raw_output: "Inspected auth flow and found the failing check",
+                content: [
+                    {
+                        type: "content",
+                        content: { type: "text", text: "Inspected auth flow and found the failing check" },
+                    },
+                ],
+            },
+        },
+    });
+    assert.equal(session.toolCalls.get(toolCall.tool_call_id)?.raw_output, "Inspected auth flow and found the failing check");
+});
+test("handleSdkMessage suppresses ToolSearch bridge events without denying SDK use", () => {
+    const session = makeSessionState();
+    const events = captureBridgeEvents(() => {
+        handleSdkMessage(session, {
+            type: "stream_event",
+            event: {
+                type: "content_block_start",
+                content_block: {
+                    type: "server_tool_use",
+                    id: "tool-search-1",
+                    name: "ToolSearch",
+                    input: { query: "src/" },
+                },
+            },
+            uuid: "message-search-start",
+            session_id: "session-1",
+        });
+        handleSdkMessage(session, {
+            type: "tool_progress",
+            tool_use_id: "tool-search-1",
+            tool_name: "ToolSearch",
+            uuid: "message-search-progress",
+            session_id: "session-1",
+        });
+        handleSdkMessage(session, {
+            type: "user",
+            parent_tool_use_id: "tool-search-1",
+            tool_use_result: { content: "matched src/main.rs", is_error: false },
+            message: {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_search_tool_result",
+                        tool_use_id: "tool-search-1",
+                        content: "matched src/main.rs",
+                        is_error: false,
+                    },
+                ],
+            },
+            uuid: "message-search-result",
+            session_id: "session-1",
+        });
+        handleSdkMessage(session, {
+            type: "tool_use_summary",
+            summary: "Found source files",
+            preceding_tool_use_ids: ["tool-search-1"],
+            uuid: "message-search-summary",
+            session_id: "session-1",
+        });
+    });
+    assert.deepEqual(events, []);
+    assert.equal(session.hiddenToolUseIds.has("tool-search-1"), true);
+    assert.equal(session.toolCalls.has("tool-search-1"), false);
+});
 test("handleTaskSystemMessage applies task_updated description patches to the linked task", () => {
     const session = makeSessionState();
     const events = captureBridgeEvents(() => {
@@ -873,8 +1037,7 @@ test("buildQueryOptions trims language before appending system prompt", () => {
     assert.deepEqual(options.systemPrompt, {
         type: "preset",
         preset: "claude_code",
-        append: "Always respond to the user in German unless the user explicitly asks for a different language. " +
-            "Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.",
+        append: `${BRIDGE_RUNTIME_GUARD_PROMPT} ${GERMAN_LANGUAGE_PROMPT}`,
     });
 });
 test("parseCommandEnvelope rejects missing required fields", () => {
@@ -1139,7 +1302,28 @@ test("buildApiRetryUpdate maps SDK api_retry messages to wire shape", () => {
         error_status: null,
         error: "unknown",
     });
+    assert.deepEqual(buildApiRetryUpdate({
+        attempt: 1,
+        max_retries: 10,
+        retry_delay_ms: 549.8881698459426,
+        error_status: null,
+        error: "unexpected",
+    }), {
+        type: "api_retry_update",
+        attempt: 1,
+        max_retries: 10,
+        retry_delay_ms: 549.8881698459426,
+        error_status: null,
+        error: "unknown",
+    });
     assert.equal(buildApiRetryUpdate({ attempt: 1 }), null);
+    assert.equal(buildApiRetryUpdate({
+        attempt: 1,
+        max_retries: 10,
+        retry_delay_ms: -1,
+        error_status: null,
+        error: "server_error",
+    }), null);
 });
 test("normalizeSettingsParseError accepts only SDK-shaped errors", () => {
     assert.deepEqual(normalizeSettingsParseError({
@@ -1673,7 +1857,7 @@ test("looksLikeAuthRequired detects login hints", () => {
     assert.equal(looksLikeAuthRequired("normal tool output"), false);
 });
 test("agent sdk version compatibility check matches pinned version", () => {
-    assert.equal(resolveInstalledAgentSdkVersion(), "0.2.112");
+    assert.equal(resolveInstalledAgentSdkVersion(), "0.3.146");
     assert.equal(agentSdkVersionCompatibilityError(), undefined);
 });
 test("mapSessionMessagesToUpdates maps message content blocks", () => {
@@ -1735,6 +1919,55 @@ test("mapSessionMessagesToUpdates maps message content blocks", () => {
     assert.equal(variantCounts.get("tool_call"), 1);
     assert.equal(variantCounts.get("tool_call_update"), 1);
 });
+test("mapSessionMessagesToUpdates suppresses ToolSearch history blocks", () => {
+    const updates = mapSessionMessagesToUpdates([
+        {
+            type: "assistant",
+            uuid: "a1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "assistant",
+                content: [
+                    {
+                        type: "server_tool_use",
+                        id: "tool-search-1",
+                        name: "ToolSearch",
+                        input: { query: "src/" },
+                    },
+                    { type: "tool_use", id: "tool-bash", name: "Bash", input: { command: "echo ok" } },
+                ],
+            },
+        },
+        {
+            type: "user",
+            uuid: "u1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_search_tool_result",
+                        tool_use_id: "tool-search-1",
+                        content: "matched src/main.rs",
+                        is_error: false,
+                    },
+                    {
+                        type: "tool_result",
+                        tool_use_id: "tool-bash",
+                        content: "ok",
+                        is_error: false,
+                    },
+                ],
+            },
+        },
+    ]);
+    const toolCalls = updates.filter((update) => update.type === "tool_call");
+    const toolUpdates = updates.filter((update) => update.type === "tool_call_update");
+    assert.deepEqual(toolCalls.map((update) => update.tool_call.tool_call_id), ["tool-bash"]);
+    assert.deepEqual(toolUpdates.map((update) => update.tool_call_update.tool_call_id), ["tool-bash"]);
+});
 test("mapSessionMessagesToUpdates preserves parallel tool results", () => {
     const updates = mapSessionMessagesToUpdates([
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",
@@ -29,7 +29,10 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.112"
+    "@anthropic-ai/claude-agent-sdk": "0.3.146",
+    "@anthropic-ai/sdk": "0.97.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "zod": "4.4.3"
   },
   "scripts": {
     "postinstall": "node ./scripts/postinstall.js",

package/scripts/postinstall.js

@@ -4,6 +4,7 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const https = require("node:https");
+const { spawnSync } = require("node:child_process");
 const { pipeline } = require("node:stream/promises");
 
 const TARGETS = {
@@ -14,6 +15,8 @@ const TARGETS = {
 };
 
 const MAX_REDIRECTS = 5;
+const BRIDGE_RUNTIME_EXE =
+  process.platform === "win32" ? "claude-rs-bridge-node.exe" : "claude-rs-bridge-node";
 
 function getTargetInfo() {
   return TARGETS[`${process.platform}:${process.arch}`];
@@ -56,6 +59,49 @@ async function downloadFile(url, outPath, redirects = 0) {
   });
 }
 
+function installRenamedBridgeRuntime(installDir) {
+  const sourcePath = process.execPath;
+  const runtimePath = path.join(installDir, BRIDGE_RUNTIME_EXE);
+
+  try {
+    if (!sourcePath || !fs.existsSync(sourcePath)) {
+      throw new Error("current Node.js executable could not be resolved");
+    }
+
+    if (path.resolve(sourcePath) !== path.resolve(runtimePath)) {
+      fs.copyFileSync(sourcePath, runtimePath);
+    }
+
+    if (process.platform !== "win32") {
+      fs.chmodSync(runtimePath, 0o755);
+    }
+
+    const result = spawnSync(runtimePath, ["--version"], {
+      encoding: "utf8",
+      windowsHide: true
+    });
+    const version = String(result.stdout || "").trim();
+
+    if (result.status !== 0 || !/^v\d+\./.test(version)) {
+      throw new Error(
+        `copied runtime failed validation${result.stderr ? `: ${result.stderr.trim()}` : ""}`
+      );
+    }
+
+    console.log(`Installed renamed Agent SDK bridge runtime ${BRIDGE_RUNTIME_EXE} (${version})`);
+  } catch (error) {
+    try {
+      fs.rmSync(runtimePath, { force: true });
+    } catch {
+      // Best-effort cleanup only; the Rust binary can still fall back to `node`.
+    }
+    console.warn(
+      `Skipping renamed Agent SDK bridge runtime: ${error.message}. ` +
+        "claude-rs will fall back to the `node` executable on PATH."
+    );
+  }
+}
+
 async function main() {
   const info = getTargetInfo();
   if (!info) {
@@ -83,6 +129,8 @@ async function main() {
     fs.chmodSync(binaryPath, 0o755);
   }
 
+  installRenamedBridgeRuntime(installDir);
+
   console.log(`Installed claude-code-rust ${version} (${info.target})`);
 }