Claude Code. Any Model. The most powerful AI coding agent now speaks every language.
diff --git a/packages/cli/src/handlers/native-handler.ts b/packages/cli/src/handlers/native-handler.ts
index 405c9ce..0353d1f 100644
--- a/packages/cli/src/handlers/native-handler.ts
+++ b/packages/cli/src/handlers/native-handler.ts
@@ -2,6 +2,15 @@ import type { Context } from "hono";
import type { ModelHandler } from "./types.js";
import { log, maskCredential } from "../logger.js";
import { wrapAnthropicError } from "./shared/anthropic-error.js";
+import {
+ loadAdvisorSwapConfig,
+ logAdvisorEvent,
+ recordAdvisorEventsFromChunk,
+ rewriteAdvisorToolResults,
+ stripAdvisorBeta,
+ stubAdvisorAdvice,
+ swapAdvisorToolInBody,
+} from "./native-handler-advisor.js";
export class NativeHandler implements ModelHandler {
private apiKey?: string;
@@ -17,6 +26,62 @@ export class NativeHandler implements ModelHandler {
const originalHeaders = c.req.header();
const target = payload.model;
+ // -------------------------------------------------------------------
+ // Advisor-swap experiment (opt-in via CLAUDISH_SWAP_ADVISOR=1).
+ // No-op if the env var is unset. See native-handler-advisor.ts.
+ //
+ // Two-way mutation on each request:
+ // 1. Outbound swap: advisor_20260301 server tool → regular tool named
+ // "advisor". Also strips advisor-tool-2026-03-01 beta flag.
+ // 2. Inbound rewrite (Stage 2): any tool_result blocks targeting an
+ // advisor tool_use_id we've previously seen in a streamed response
+ // get their error payload replaced with stubbed advisor advice.
+ // -------------------------------------------------------------------
+ const advisorCfg = loadAdvisorSwapConfig();
+ let advisorSwapped: ReturnType<typeof swapAdvisorToolInBody> = null;
+ let advisorRewrittenIds: string[] = [];
+ if (advisorCfg.enabled) {
+ // Stage 1: tool-definition swap (outbound).
+ advisorSwapped = swapAdvisorToolInBody(payload);
+ if (advisorSwapped) {
+ log("[Native][advisor-swap] replaced advisor_20260301 with regular tool 'advisor'");
+ logAdvisorEvent(advisorCfg, {
+ kind: "swap_applied",
+ model: target,
+ originalTool: advisorSwapped.originalTool,
+ regularTool: advisorSwapped.regularTool,
+ });
+ }
+
+ // Stage 2: tool_result rewrite (inbound). Runs AFTER the Stage-1 swap
+ // so it sees the possibly-mutated payload. In practice the two are
+ // orthogonal — rewrite looks at messages[].content tool_result blocks,
+ // swap looks at tools[].
+ advisorRewrittenIds = rewriteAdvisorToolResults(payload, stubAdvisorAdvice);
+ if (advisorRewrittenIds.length > 0) {
+ log(
+ `[Native][advisor-swap] rewrote ${advisorRewrittenIds.length} error tool_result(s) with stub advice: ${advisorRewrittenIds.join(", ")}`
+ );
+ logAdvisorEvent(advisorCfg, {
+ kind: "tool_result_rewritten",
+ ids: advisorRewrittenIds,
+ model: target,
+ });
+ }
+
+ // Dump request body (trimmed) so we can inspect follow-ups that carry
+ // tool_result blocks — critical evidence for Stage 2 debugging.
+ if (advisorCfg.dumpBodies) {
+ logAdvisorEvent(advisorCfg, {
+ kind: "request_body",
+ swapApplied: !!advisorSwapped,
+ rewrittenIds: advisorRewrittenIds,
+ model: target,
+ body: trimForLog(payload),
+ });
+ }
+ }
+
log("\n=== [NATIVE] Claude Code → Anthropic API Request ===");
log(
`[Native] x-api-key: ${originalHeaders["x-api-key"] ? maskCredential(originalHeaders["x-api-key"]) : "(not set)"}`
@@ -41,7 +106,26 @@ export class NativeHandler implements ModelHandler {
headers["x-api-key"] = originalHeaders["x-api-key"];
}
if (originalHeaders["anthropic-beta"]) {
- headers["anthropic-beta"] = originalHeaders["anthropic-beta"];
+ const incomingBeta = originalHeaders["anthropic-beta"];
+ if (advisorSwapped) {
+ // When we swap the advisor tool we must also strip the matching beta
+ // flag; otherwise Anthropic rejects the request (beta enabled but no
+ // matching server tool declared).
+ const { stripped, changed } = stripAdvisorBeta(incomingBeta);
+ if (changed) {
+ log(
+ `[Native][advisor-swap] stripped advisor-tool beta; before=${incomingBeta} after=${stripped ?? "(empty)"}`
+ );
+ logAdvisorEvent(advisorCfg, {
+ kind: "beta_stripped",
+ before: incomingBeta,
+ after: stripped ?? "",
+ });
+ }
+ if (stripped) headers["anthropic-beta"] = stripped;
+ } else {
+ headers["anthropic-beta"] = incomingBeta;
+ }
}
// Execute fetch
@@ -75,7 +159,11 @@ export class NativeHandler implements ModelHandler {
controller.enqueue(value);
// Basic logging
- buffer += decoder.decode(value, { stream: true });
+ const chunkText = decoder.decode(value, { stream: true });
+ buffer += chunkText;
+ // Advisor tap: extract any advisor tool_use ids and record
+ // stream events to the log (no-op when disabled).
+ recordAdvisorEventsFromChunk(advisorCfg, chunkText);
const lines = buffer.split("\n");
buffer = lines.pop() || "";
for (const line of lines) if (line.trim()) eventLog += line + "\n";
@@ -104,6 +192,17 @@ export class NativeHandler implements ModelHandler {
log("\n=== [NATIVE] Response ===");
log(JSON.stringify(data, null, 2));
+ // Advisor tap for the non-streaming branch (mostly for title-classifier
+ // calls on Haiku which return JSON). Picks up any advisor tool_use ids
+ // we might miss in SSE.
+ if (advisorCfg.enabled) {
+ try {
+ recordAdvisorEventsFromChunk(advisorCfg, JSON.stringify(data));
+ } catch {
+ // ignore scan failures — logging-only
+ }
+ }
+
const responseHeaders: Record<string, string> = { "Content-Type": "application/json" };
if (anthropicResponse.headers.has("anthropic-version")) {
responseHeaders["anthropic-version"] = anthropicResponse.headers.get("anthropic-version")!;
@@ -120,3 +219,29 @@ export class NativeHandler implements ModelHandler {
// No state to clean up
}
}
+
+/**
+ * Produces a logging-friendly copy of a request payload. Trims long text
+ * fields (system prompts can exceed 30KB) so the advisor-swap log stays
+ * readable. Preserves block structure so you can still inspect the shape
+ * of tool_use / tool_result / server_tool_use blocks.
+ */
+function trimForLog(payload: any): any {
+ const TEXT_TRUNC = 400;
+ const clone = structuredClone(payload);
+ const trimStr = (s: string) =>
+ typeof s === "string" && s.length > TEXT_TRUNC
+ ? s.slice(0, TEXT_TRUNC) + `… [+${s.length - TEXT_TRUNC} chars]`
+ : s;
+ const walk = (v: any): any => {
+ if (typeof v === "string") return trimStr(v);
+ if (Array.isArray(v)) return v.map(walk);
+ if (v && typeof v === "object") {
+ const out: any = {};
+ for (const [k, val] of Object.entries(v)) out[k] = walk(val);
+ return out;
+ }
+ return v;
+ };
+ return walk(clone);
+}