@code-yeongyu/senpi 2026.7.16 → 2026.7.17-3

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -1,3 +1,4 @@
+import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "./bridge/protocol.ts";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
@@ -35,6 +36,8 @@ const SESSION_LIFECYCLE_EVENTS = [
 
 type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
 
+type CodemodeEvent = SessionLifecycleEvent | "model_select";
+
 type TrackedExecution = {
 	readonly promise: Promise<unknown>;
 	readonly controller: AbortController;
@@ -51,7 +54,7 @@ type SessionRuntime = {
 
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
-	on(event: SessionLifecycleEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
+	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
 }
@@ -75,6 +78,32 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
+	let activeRuntime: SessionRuntime | undefined;
+	let activeModelId: string | undefined;
+	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
+		pi.registerTool(
+			createEvalTool({
+				enabledLanguages: runtime.enabledLanguages,
+				kernelManager: manager,
+				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+				executeTool: runtime.executeTool,
+				complete,
+				settings: runtime.settings,
+				artifactsDir: runtime.artifactsDir,
+				executionTracker: manager,
+				renderers,
+				spawns: runtime.spawns,
+				spawnDefaultAgent: runtime.settings.taskTools.task,
+				hostLine: hostLine(),
+				...(modelId === undefined ? {} : { modelId }),
+			}),
+		);
+	};
+	const dropRuntime = async (): Promise<void> => {
+		activeRuntime = undefined;
+		activeModelId = undefined;
+		await manager.dispose();
+	};
 	pi.registerTool(
 		createEvalTool({
 			enabledLanguages: { py: true, js: true, rb: true, jl: true },
@@ -85,6 +114,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			settings: defaultCodemodeSettings,
 			executionTracker: manager,
 			renderers,
+			hostLine: hostLine(),
 		}),
 	);
 
@@ -92,25 +122,35 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		const generation = manager.beginReplacement();
 		const runtime = await createRuntime(pi, ctx, event, complete, options);
 		if (!(await manager.replace(generation, runtime.manager))) return;
-		pi.registerTool(
-			createEvalTool({
-				enabledLanguages: runtime.enabledLanguages,
-				kernelManager: manager,
-				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
-				executeTool: runtime.executeTool,
-				complete,
-				settings: runtime.settings,
-				artifactsDir: runtime.artifactsDir,
-				executionTracker: manager,
-				renderers,
-				spawns: runtime.spawns,
-				spawnDefaultAgent: runtime.settings.taskTools.task,
-			}),
-		);
+		activeRuntime = runtime;
+		activeModelId = ctx.model?.id;
+		registerEvalForRuntime(runtime, activeModelId);
+	});
+	pi.on("session_shutdown", async () => dropRuntime());
+	pi.on("session_before_switch", async () => dropRuntime());
+	pi.on("session_before_fork", async () => dropRuntime());
+	pi.on("model_select", async (event) => {
+		const runtime = activeRuntime;
+		if (runtime === undefined) return;
+		const modelId = modelIdFrom(event);
+		if (modelId === undefined || modelId === activeModelId) return;
+		activeModelId = modelId;
+		registerEvalForRuntime(runtime, modelId);
 	});
-	pi.on("session_shutdown", async () => manager.dispose());
-	pi.on("session_before_switch", async () => manager.dispose());
-	pi.on("session_before_fork", async () => manager.dispose());
+}
+
+function hostLine(): string {
+	const cpu = os.cpus()[0]?.model?.trim();
+	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]
+		.filter((part): part is string => !!part)
+		.join(" \u00b7 ");
+}
+
+function modelIdFrom(event: unknown): string | undefined {
+	if (typeof event !== "object" || event === null || !("model" in event)) return undefined;
+	const model = event.model;
+	if (typeof model !== "object" || model === null || !("id" in model)) return undefined;
+	return typeof model.id === "string" ? model.id : undefined;
 }
 
 class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {

package/node_modules/@code-yeongyu/senpi-codemode/src/prompt/eval-prompt.ts

@@ -14,6 +14,35 @@ export interface EvalPromptParts {
 export interface EvalPromptOptions {
 	readonly spawns: boolean;
 	readonly spawnDefaultAgent?: string;
+	/** Active model id; selects the emphasis dialect of the batching guidance. */
+	readonly modelId?: string;
+	/** Preformatted host line (e.g. "darwin arm64 · Apple M5 Max · 18 cores"); enables the host-sizing note. */
+	readonly hostLine?: string;
+}
+
+/** Prompt dialect for the eval-first batching emphasis. */
+export type EvalEmphasisStyle = "default" | "claude" | "codex" | "kimi";
+
+const CLAUDE_MODEL_RE = /(^|[/.:])claude[-.]/i;
+const GLM_MODEL_RE = /(^|[/.:@-])glm[-.]?\d/i;
+const KIMI_MODEL_RE = /(^|[/.:])kimi[-.]/i;
+const OPENAI_MODEL_RE = /(^|[/.:])(gpt|chatgpt|codex)[-.]|(^|[/.:])o[134](?:[-.]|$)/i;
+
+/**
+ * Selects the eval-first batching dialect for a model id:
+ * - `claude`: Claude/GLM — direct imperatives; both are steered most reliably
+ *   by explicit tagged directives (GLM prompting guidance routes to Claude's).
+ * - `codex`: OpenAI reasoning families — terse bounded rules, no emphasis spam.
+ * - `kimi`: Kimi K-series — positive operational constraints; all-caps NEVER
+ *   directives make K2.x overthink instead of comply.
+ * - `default`: everything else (and no model) — maximum-emphasis fallback.
+ */
+export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyle {
+	if (!modelId) return "default";
+	if (CLAUDE_MODEL_RE.test(modelId) || GLM_MODEL_RE.test(modelId)) return "claude";
+	if (KIMI_MODEL_RE.test(modelId)) return "kimi";
+	if (OPENAI_MODEL_RE.test(modelId)) return "codex";
+	return "default";
 }
 
 type ContextValue = string | boolean;
@@ -57,7 +86,24 @@ const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 
 Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after \`reset\`, a kernel crash, or a \`NameError\`/\`ReferenceError\` proving the state is gone.
 
-**Batch through eval.** One cell replaces many one-shot tool calls: loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time, post-process \`tool.<name>()\` results programmatically, and fan independent calls through \`parallel(thunks)\` within the cell — never one call per turn.
+{{#if styleClaude}}<eval_first_batching>
+\`eval\` is your default execution surface: if a step needs more than one tool call, write ONE cell that performs the whole step — never issue the calls one at a time.
+- Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
+- Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
+- Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
+</eval_first_batching>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
+- Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}Treat eval as the standard way to execute any step involving several tool calls: write one cell that performs the whole step.
+- When lookups are independent, run them together with \`parallel(thunks)\` in that cell; when one result feeds the next, keep them sequential inside the same cell.
+- Loop or comprehend over file sets with \`read()\`/stdlib, post-process \`tool.<name>()\` results programmatically, and put try/except around each risky call so the rest of the batch completes.
+- Filter and aggregate results in the kernel, then return the distilled facts.{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
+- **PLAN THE WHOLE STEP, THEN BATCH IT.** Enumerate every read/search/lookup the step needs and dispatch ALL independent ones through \`parallel(thunks)\` in one cell.
+- **WRITE REAL CODE, NOT CALL LISTS.** Loop or comprehend over file sets with \`read()\`/stdlib, branch \`if\`/\`else\` per case, post-process \`tool.<name>()\` results programmatically, and wrap EVERY risky call in try/except so ONE failure NEVER kills the batch.
+- **DISTILL IN-KERNEL.** Filter, diff, and aggregate in code before returning; return facts, NOT dumps.{{/if}}
+{{#if hostLine}}
+Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
+{{/if}}
 
 Fields:
 
@@ -129,6 +175,7 @@ export function buildEvalPrompt(
 		throw new Error("no kernels enabled for eval prompt");
 	}
 	const spawnDefaultAgent = options.spawnDefaultAgent ?? "task";
+	const style = evalEmphasisStyle(options.modelId);
 	const context: Context = {
 		py: enabled.py,
 		js: enabled.js,
@@ -136,6 +183,11 @@ export function buildEvalPrompt(
 		jl: enabled.jl,
 		spawns: options.spawns,
 		spawnDefaultAgent,
+		styleClaude: style === "claude",
+		styleCodex: style === "codex",
+		styleKimi: style === "kimi",
+		styleDefault: style === "default",
+		hostLine: options.hostLine ?? "",
 	};
 	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
 		.map((example) => {
@@ -155,12 +207,26 @@ export function buildEvalPrompt(
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",
 		promptGuidelines: [
-			"Use eval for incremental code execution when a persistent JS, Python, Ruby, or Julia kernel is available.",
+			BATCHING_GUIDELINES[style],
 			"Use eval reset only when a language kernel must be wiped; reset is scoped to the selected language.",
 		],
 	};
 }
 
+/**
+ * System-prompt guideline per emphasis dialect. The default dialect carries
+ * maximum emphasis so unmapped models still batch through eval; the others are
+ * tuned to what steers that family reliably.
+ */
+const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
+	default:
+		"**EVAL FIRST.** Any step needing MORE THAN ONE tool call MUST be ONE eval cell: run independent calls in parallel, wrap risky calls in try/except, and return distilled facts — NEVER a chain of single tool calls.",
+	claude:
+		"Prefer eval for any step needing more than one tool call: one cell that runs independent calls in parallel, handles per-call failures in code, and returns distilled facts.",
+	codex: "Route multi-call steps through eval: one cell per step, independent calls dispatched in parallel; fall back to direct tool calls when one call is sufficient or each result changes the next decision.",
+	kimi: "Treat eval as the standard way to execute multi-call steps: one cell that runs independent calls in parallel, handles failures per item, and returns distilled facts.",
+};
+
 function renderTemplate(template: string, context: Context): string {
 	let index = 0;
 	const [rendered, nextIndex] = renderUntil(template, context, index, []);

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool.ts

@@ -39,6 +39,10 @@ export interface CreateEvalToolOptions {
 	readonly spawns?: boolean;
 	/** Default agent name surfaced in the agent() helper docs when spawns are enabled. */
 	readonly spawnDefaultAgent?: string;
+	/** Active model id; selects the emphasis dialect of the eval prompt. */
+	readonly modelId?: string;
+	/** Preformatted host line rendered into the prompt's host-sizing note. */
+	readonly hostLine?: string;
 }
 
 interface EvalCellInvocation {
@@ -152,6 +156,8 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
+		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
+		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
 	});
 	const languages = enabledLanguageList(options.enabledLanguages);
 	return {

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/render.ts

@@ -725,6 +725,12 @@ export function renderEvalCall(
 	context: RenderContext,
 ): EvalRenderComponent {
 	const component = componentFor(context);
+	if (context.hasResult === true) {
+		// The result renderer owns the full pending -> running -> done frame once a result exists.
+		// Rendering the call frame too would stack a duplicate box, so yield to it here.
+		component.setBlocks([]);
+		return component;
+	}
 	if (theme === undefined && context.spinnerFrame === undefined) {
 		const title = args.title === undefined ? "" : ` ${args.title}`;
 		const reset = args.reset === true ? " reset" : "";

package/node_modules/@earendil-works/pi-agent-core/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@earendil-works/pi-agent-core",
 	"private": true,
-	"version": "2026.7.16",
+	"version": "2026.7.17-3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,7 +30,7 @@
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"dependencies": {
-		"@earendil-works/pi-ai": "^2026.7.16",
+		"@earendil-works/pi-ai": "^2026.7.17-3",
 		"ignore": "7.0.5",
 		"typebox": "1.1.38",
 		"yaml": "2.9.0"

package/node_modules/@earendil-works/pi-ai/README.md

@@ -747,7 +747,7 @@ Many models support thinking/reasoning capabilities where they can show their in
 const model = models.getModel('anthropic', 'claude-sonnet-4-5')!;
 // or models.getModel('openai', 'gpt-5-mini');
 // or models.getModel('google', 'gemini-2.5-flash');
-// or models.getModel('xai', 'grok-code-fast-1');
+// or models.getModel('xai', 'grok-4.5');
 
 // Check if model supports reasoning
 if (model.reasoning) {

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAgKrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAuDhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAghBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAsTzE,CAAC;AAoEF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAgKrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AA6DhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAuiBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAwUzE,CAAC;AAoEF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js

@@ -152,6 +152,12 @@ function getAnthropicCompat(model) {
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
         supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
+        // Default: first-party Anthropic only. Anthropic-compatible providers
+        // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
+        // search but reject the replayed server_tool_use / web_search_tool_result
+        // blocks on the next request (kimi-coding 400s with `tool_call_id is not
+        // found`).
+        supportsWebSearch: model.compat?.supportsWebSearch ?? isAnthropicApiBaseUrl(model.baseUrl),
     };
 }
 /**
@@ -227,6 +233,23 @@ function lastAnthropicFallbackBoundary(content) {
 function isAnthropicServerToolUseBlock(raw) {
     return isRecord(raw) && raw.type === "server_tool_use" && typeof raw.id === "string";
 }
+// Only tool_use-shaped provider-native blocks (server_tool_use, mcp_tool_use)
+// stream their input via input_json_delta. Result-shaped blocks must replay
+// byte-for-byte (encrypted_content), so never merge an `input` into them.
+function isProviderNativeToolUseBlock(raw) {
+    return isRecord(raw) && (raw.type === "server_tool_use" || raw.type === "mcp_tool_use");
+}
+// Endpoints without `supportsWebSearch` reject replayed web-search server-tool
+// blocks (kimi-coding 400s with `tool_call_id is not found`), wedging every
+// subsequent request of the session. Dropping the pair loses the searched
+// context but keeps the conversation usable.
+function isAnthropicWebSearchReplayBlock(raw) {
+    if (!isRecord(raw))
+        return false;
+    if (raw.type === "web_search_tool_result")
+        return true;
+    return raw.type === "server_tool_use" && raw.name === "web_search";
+}
 // tool_use ids referenced by server-tool result blocks in content[0, boundary).
 // A pre-boundary `server_tool_use` whose id is absent here is unpaired — the
 // fallback interrupted the declined attempt before its result arrived — so
@@ -339,27 +362,28 @@ function rejectsComputerUseBeta(model) {
     return ((model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic")) ||
         matchesModelMarker(model, UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS));
 }
+function isAnthropicWebSearchToolType(toolType) {
+    return toolType.startsWith("web_search_");
+}
 function sanitizeUnsupportedNativeTools(model, params) {
     const payload = params;
     const headers = stringRecord(payload.headers);
     const headerSanitization = rejectsComputerUseBeta(model)
         ? removeComputerUseBetaHeader(headers)
         : { changed: false };
+    const rejectsNativeWebSearch = !getAnthropicCompat(model).supportsWebSearch;
     const tools = payload.tools;
     const sanitized = { ...payload };
     let changed = false;
-    const removedToolNames = new Set();
     if (Array.isArray(tools)) {
         const supportedTools = [];
         for (const tool of tools) {
             const hookTool = tool;
             if (isRecord(hookTool) &&
                 typeof hookTool.type === "string" &&
-                rejectsNativeComputerTool(model, hookTool.type)) {
+                (rejectsNativeComputerTool(model, hookTool.type) ||
+                    (rejectsNativeWebSearch && isAnthropicWebSearchToolType(hookTool.type)))) {
                 changed = true;
-                if (typeof hookTool.name === "string") {
-                    removedToolNames.add(hookTool.name);
-                }
                 continue;
             }
             supportedTools.push(tool);
@@ -384,7 +408,10 @@ function sanitizeUnsupportedNativeTools(model, params) {
     }
     if (changed && isRecord(sanitized.tool_choice)) {
         const toolChoiceName = sanitized.tool_choice.name;
-        const shouldRemoveToolChoice = (typeof toolChoiceName === "string" && removedToolNames.has(toolChoiceName)) || sanitized.tools === undefined;
+        const hasSelectedTool = typeof toolChoiceName === "string" &&
+            Array.isArray(sanitized.tools) &&
+            sanitized.tools.some((tool) => isRecord(tool) && tool.name === toolChoiceName);
+        const shouldRemoveToolChoice = sanitized.tools === undefined || (typeof toolChoiceName === "string" && !hasSelectedTool);
         if (shouldRemoveToolChoice) {
             delete sanitized.tool_choice;
         }
@@ -764,6 +791,12 @@ export const stream = (model, context, options) => {
                                 partial: output,
                             });
                         }
+                        else if (block && block.type === "providerNative" && isProviderNativeToolUseBlock(block.raw)) {
+                            // Server-side tool blocks (server_tool_use) stream their input
+                            // the same way tool_use does; the block captured at
+                            // content_block_start still has `input: {}`.
+                            block.partialJson = (block.partialJson ?? "") + event.delta.partial_json;
+                        }
                     }
                     else if (event.delta.type === "signature_delta") {
                         const index = blocks.findIndex((b) => b.index === event.index);
@@ -807,6 +840,13 @@ export const stream = (model, context, options) => {
                                 partial: output,
                             });
                         }
+                        else if (block.type === "providerNative") {
+                            const partialJson = block.partialJson;
+                            delete block.partialJson;
+                            if (partialJson !== undefined && isRecord(block.raw)) {
+                                block.raw = { ...block.raw, input: parseStreamingJson(partialJson) };
+                            }
+                        }
                     }
                 }
                 else if (event.type === "message_delta") {
@@ -859,6 +899,13 @@ export const stream = (model, context, options) => {
         catch (error) {
             for (const block of output.content) {
                 delete block.index;
+                // An aborted stream never reaches content_block_stop; keep whatever
+                // provider-native input accumulated, mirroring toolCall's partial
+                // arguments.
+                const scratch = block.partialJson;
+                if (block.type === "providerNative" && scratch !== undefined && isRecord(block.raw)) {
+                    block.raw = { ...block.raw, input: parseStreamingJson(scratch) };
+                }
                 // partialJson is only a streaming scratch buffer; never persist it.
                 delete block.partialJson;
             }
@@ -1199,6 +1246,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
     // Tool calls from a declined pre-fallback attempt are dropped from their
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
+    const rejectsNativeWebSearchReplay = !getAnthropicCompat(model).supportsWebSearch;
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -1320,8 +1368,11 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     });
                 }
                 else if (block.type === "providerNative") {
-                    if (isSameModel && isReplayableAnthropicProviderNativeBlock(block.raw))
+                    if (isSameModel &&
+                        isReplayableAnthropicProviderNativeBlock(block.raw) &&
+                        !(rejectsNativeWebSearchReplay && isAnthropicWebSearchReplayBlock(block.raw))) {
                         blocks.push(block.raw);
+                    }
                 }
             }
             if (blocks.length === 0)