Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

7.3 KB
Raw Blame
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);
+}