mini-coder 0.0.21 → 0.0.22

package/dist/mc.js

@@ -1791,7 +1791,7 @@ async function renderTurn(events, spinner, opts) {
 
 // src/cli/output.ts
 var HOME = homedir3();
-var PACKAGE_VERSION = "0.0.21";
+var PACKAGE_VERSION = "0.0.22";
 function tildePath(p) {
   return p.startsWith(HOME) ? `~${p.slice(HOME.length)}` : p;
 }
@@ -4283,6 +4283,17 @@ var SUPPORTED_PROVIDERS = [
   "ollama"
 ];
 var ZEN_BASE2 = "https://opencode.ai/zen/v1";
+var REDACTED_HEADERS = new Set(["authorization"]);
+function redactHeaders(headers) {
+  if (!headers)
+    return;
+  const h = new Headers(headers);
+  const out = {};
+  h.forEach((v, k) => {
+    out[k] = REDACTED_HEADERS.has(k) ? "[REDACTED]" : v;
+  });
+  return out;
+}
 function createFetchWithLogging() {
   const customFetch = async (input, init) => {
     if (init?.body) {
@@ -4292,14 +4303,14 @@ function createFetchWithLogging() {
         logApiEvent("Provider Request", {
           url: input.toString(),
           method: init.method,
-          headers: init.headers,
+          headers: redactHeaders(init.headers),
           body: bodyJson
         });
       } catch {
         logApiEvent("Provider Request", {
           url: input.toString(),
           method: init.method,
-          headers: init.headers,
+          headers: redactHeaders(init.headers),
           body: init.body
         });
       }
@@ -4309,6 +4320,59 @@ function createFetchWithLogging() {
   return customFetch;
 }
 var fetchWithLogging = createFetchWithLogging();
+var OAUTH_STRIP_BETAS = new Set(["structured-outputs-2025-11-13"]);
+function sanitizeOAuthBody(body) {
+  try {
+    const json = JSON.parse(body);
+    if (Array.isArray(json.tools)) {
+      for (const tool of json.tools) {
+        if (tool.input_schema) {
+          tool.input_schema = {
+            type: "object",
+            properties: tool.input_schema.properties ?? {},
+            required: tool.input_schema.required ?? []
+          };
+        }
+      }
+    }
+    if (Array.isArray(json.messages)) {
+      for (const msg of json.messages) {
+        if (!Array.isArray(msg.content))
+          continue;
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            delete block.caller;
+          }
+        }
+      }
+    }
+    return JSON.stringify(json);
+  } catch {
+    return body;
+  }
+}
+function createOAuthFetch() {
+  const baseFetch = createFetchWithLogging();
+  const oauthFetch = async (input, init) => {
+    let opts = init;
+    if (opts?.headers) {
+      const h = new Headers(opts.headers);
+      const beta = h.get("anthropic-beta");
+      if (beta) {
+        const filtered = beta.split(",").filter((b) => !OAUTH_STRIP_BETAS.has(b)).join(",");
+        h.set("anthropic-beta", filtered);
+      }
+      h.set("user-agent", "claude-cli/2.1.75");
+      h.set("x-app", "cli");
+      opts = { ...opts, headers: Object.fromEntries(h.entries()) };
+    }
+    if (opts?.body) {
+      opts = { ...opts, body: sanitizeOAuthBody(opts.body.toString()) };
+    }
+    return baseFetch(input, opts);
+  };
+  return oauthFetch;
+}
 function requireEnv(name) {
   const value = process.env[name];
   if (!value)
@@ -4399,7 +4463,7 @@ async function resolveAnthropicModel(modelId) {
         oauthAnthropicCache = {
           token,
           provider: createAnthropic({
-            fetch: fetchWithLogging,
+            fetch: createOAuthFetch(),
             authToken: token,
             headers: {
               "anthropic-beta": "claude-code-20250219,oauth-2025-04-20"
@@ -4434,6 +4498,9 @@ async function resolveModel(modelString) {
   }
   return PROVIDER_MODEL_RESOLVERS[provider](modelId);
 }
+function isAnthropicOAuth() {
+  return isLoggedIn("anthropic");
+}
 function autoDiscoverModel() {
   if (process.env.OPENCODE_API_KEY)
     return "zen/claude-sonnet-4-6";
@@ -4498,6 +4565,10 @@ function normalizeUnknownError(error) {
   return new Error(stringifyUnknown(error));
 }
 
+// src/llm-api/turn-anthropic-oauth.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { zodSchema } from "ai";
+
 // src/llm-api/turn-context.ts
 import { pruneMessages } from "ai";
 var DEFAULT_TOOL_RESULT_PAYLOAD_CAP_BYTES = 16 * 1024;
@@ -4698,629 +4769,1172 @@ function annotateAnthropicCacheBreakpoints(turnMessages, systemPrompt) {
   };
 }
 
-// src/llm-api/turn-execution.ts
-import { dynamicTool, jsonSchema } from "ai";
+// src/llm-api/turn-request.ts
+import { stepCountIs } from "ai";
 
-// src/llm-api/turn-stream-events.ts
-function shouldLogStreamChunk(c11) {
-  return c11.type !== "text-delta" && c11.type !== "reasoning" && c11.type !== "reasoning-delta";
-}
-function extractToolArgs(c11) {
-  return c11.input ?? c11.args;
-}
-function hasRenderableToolArgs(args) {
-  if (args === null || args === undefined)
-    return false;
-  if (typeof args === "string")
-    return args.trim().length > 0;
-  if (Array.isArray(args))
-    return args.length > 0;
-  if (typeof args === "object")
-    return Object.keys(args).length > 0;
-  return true;
+// src/llm-api/provider-options.ts
+var ANTHROPIC_BUDGET = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32768
+};
+var GEMINI_BUDGET = {
+  low: 4096,
+  medium: 8192,
+  high: 16384,
+  xhigh: 24575
+};
+function clampEffort(effort, max) {
+  const ORDER = ["low", "medium", "high", "xhigh"];
+  const effortIdx = ORDER.indexOf(effort);
+  const maxIdx = ORDER.indexOf(max);
+  return ORDER[Math.min(effortIdx, maxIdx)];
 }
-function mapStreamChunkToTurnEvent(c11) {
-  switch (c11.type) {
-    case "text-delta": {
-      const delta = typeof c11.text === "string" ? c11.text : "";
-      return {
-        type: "text-delta",
-        delta
-      };
-    }
-    case "reasoning-delta":
-    case "reasoning": {
-      const delta = getReasoningDeltaFromStreamChunk(c11);
-      if (delta === null)
-        return null;
-      return {
-        type: "reasoning-delta",
-        delta
-      };
-    }
-    case "tool-input-start": {
-      const args = extractToolArgs(c11);
-      const hasStableToolCallId = typeof c11.toolCallId === "string" && c11.toolCallId.trim().length > 0;
-      if (hasStableToolCallId && !hasRenderableToolArgs(args))
-        return null;
-      return {
-        type: "tool-call-start",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        args
-      };
-    }
-    case "tool-call": {
-      return {
-        type: "tool-call-start",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        args: extractToolArgs(c11)
-      };
-    }
-    case "tool-result": {
-      return {
-        type: "tool-result",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        result: "output" in c11 ? c11.output : ("result" in c11) ? c11.result : undefined,
-        isError: "isError" in c11 ? Boolean(c11.isError) : false
-      };
-    }
-    case "tool-error":
-      return {
-        type: "tool-result",
-        toolCallId: String(c11.toolCallId ?? ""),
-        toolName: String(c11.toolName ?? ""),
-        result: c11.error ?? "Tool execution failed",
-        isError: true
-      };
-    case "error": {
-      throw normalizeUnknownError(c11.error);
-    }
-    default:
-      return null;
+function getAnthropicThinkingOptions(modelId, effort) {
+  const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
+  if (isAdaptive) {
+    const isOpus = /^claude-opus-4/.test(modelId);
+    const mapped = effort === "xhigh" ? isOpus ? "max" : "high" : effort;
+    return { anthropic: { thinking: { type: "adaptive" }, effort: mapped } };
   }
+  return {
+    anthropic: {
+      thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET[effort] },
+      betas: ["interleaved-thinking-2025-05-14"]
+    }
+  };
 }
-
-// src/llm-api/turn-execution.ts
-function isZodSchema(s) {
-  return s !== null && typeof s === "object" && "_def" in s;
+function getOpenAIThinkingOptions(modelId, effort) {
+  const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
+  const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
+  return { openai: { reasoningEffort: clamped, reasoningSummary: "auto" } };
 }
-function toCoreTool(def) {
-  const schema = isZodSchema(def.schema) ? def.schema : jsonSchema(def.schema);
-  return dynamicTool({
-    description: def.description,
-    inputSchema: schema,
-    execute: async (input) => {
-      try {
-        return await def.execute(input);
-      } catch (err) {
-        throw normalizeUnknownError(err);
+function getGeminiThinkingOptions(modelId, effort) {
+  if (/^gemini-3/.test(modelId)) {
+    return {
+      google: {
+        thinkingConfig: {
+          includeThoughts: true,
+          thinkingLevel: clampEffort(effort, "high")
+        }
       }
-    }
-  });
-}
-function buildToolSet(tools) {
-  const toolSet = {};
-  for (const def of tools) {
-    toolSet[def.name] = toCoreTool(def);
+    };
   }
-  return toolSet;
-}
-function createTurnStepTracker(opts) {
-  let stepCount = 0;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let contextTokens = 0;
-  let partialMessages = [];
   return {
-    onStepFinish: (step) => {
-      opts.onStepLog({
-        stepNumber: stepCount + 1,
-        finishReason: step.finishReason,
-        usage: step.usage
-      });
-      inputTokens += step.usage?.inputTokens ?? 0;
-      outputTokens += step.usage?.outputTokens ?? 0;
-      contextTokens = step.usage?.inputTokens ?? contextTokens;
-      stepCount += 1;
-      const s = step;
-      partialMessages = s.response?.messages ?? s.messages ?? partialMessages;
-    },
-    getState: () => ({
-      stepCount,
-      inputTokens,
-      outputTokens,
-      contextTokens,
-      partialMessages
-    })
+    google: {
+      thinkingConfig: {
+        includeThoughts: true,
+        thinkingBudget: GEMINI_BUDGET[effort]
+      }
+    }
   };
 }
-var TOOL_RESULT_CHUNK_TYPES = new Set(["tool-result", "tool-error"]);
-function normalizeToolCallId(raw) {
-  if (typeof raw !== "string")
+var THINKING_STRATEGIES = [
+  {
+    supports: isAnthropicModelFamily,
+    build: getAnthropicThinkingOptions
+  },
+  {
+    supports: isOpenAIReasoningModelFamily,
+    build: getOpenAIThinkingOptions
+  },
+  {
+    supports: isGeminiModelFamily,
+    build: getGeminiThinkingOptions
+  }
+];
+function getThinkingProviderOptions(modelString, effort) {
+  if (!supportsThinking(modelString))
     return null;
-  const trimmed = raw.trim();
-  return trimmed ? trimmed : null;
-}
-function normalizeToolName(raw) {
-  if (typeof raw !== "string")
-    return "tool";
-  const trimmed = raw.trim();
-  return trimmed || "tool";
+  const { modelId } = parseModelString(modelString);
+  for (const strategy of THINKING_STRATEGIES) {
+    if (!strategy.supports(modelString))
+      continue;
+    return strategy.build(modelId, effort);
+  }
+  return null;
 }
-function isRecord5(value) {
-  return value !== null && typeof value === "object";
+var CACHE_FAMILY_RULES = [
+  [isAnthropicModelFamily, "anthropic"],
+  [isGeminiModelFamily, "google"]
+];
+function getCacheFamily(modelString) {
+  for (const [match, family] of CACHE_FAMILY_RULES) {
+    if (match(modelString))
+      return family;
+  }
+  return "none";
 }
-function normalizeTextPartId(raw) {
-  if (typeof raw !== "string")
+function getCachingProviderOptions(modelString, opts) {
+  if (!opts.enabled)
     return null;
-  const trimmed = raw.trim();
-  return trimmed ? trimmed : null;
-}
-function getOpenAITextPhase2(chunk) {
-  const providerData = isRecord5(chunk.providerMetadata) ? chunk.providerMetadata : isRecord5(chunk.providerOptions) ? chunk.providerOptions : null;
-  if (!providerData)
-    return null;
-  const openai = providerData.openai;
-  if (!isRecord5(openai))
-    return null;
-  return openai.phase === "commentary" || openai.phase === "final_answer" ? openai.phase : null;
+  const family = getCacheFamily(modelString);
+  if (family === "google" && opts.googleCachedContent && opts.googleExplicitCachingCompatible !== false) {
+    return { google: { cachedContent: opts.googleCachedContent } };
+  }
+  return null;
 }
-function extractTextDelta(chunk) {
-  if (typeof chunk.text === "string")
-    return chunk.text;
-  if (typeof chunk.textDelta === "string")
-    return chunk.textDelta;
-  if (typeof chunk.delta === "string")
-    return chunk.delta;
-  return "";
+
+// src/llm-api/turn-prepare-messages.ts
+function prepareTurnMessages(input) {
+  const {
+    messages,
+    modelString,
+    toolCount,
+    systemPrompt,
+    pruningMode,
+    toolResultPayloadCapBytes,
+    promptCachingEnabled
+  } = input;
+  const apiLogOn = isApiLogEnabled();
+  const strippedRuntimeToolFields = stripToolRuntimeInputFields(messages);
+  if (strippedRuntimeToolFields !== messages && apiLogOn) {
+    logApiEvent("runtime tool input fields stripped", { modelString });
+  }
+  const geminiResult = sanitizeGeminiToolMessagesWithMetadata(strippedRuntimeToolFields, modelString, toolCount > 0);
+  if (geminiResult.repaired && apiLogOn) {
+    logApiEvent("gemini tool history repaired", {
+      modelString,
+      reason: geminiResult.reason,
+      repairedFromIndex: geminiResult.repairedFromIndex,
+      droppedMessageCount: geminiResult.droppedMessageCount,
+      tailOnlyAffected: geminiResult.tailOnlyAffected
+    });
+  }
+  const openaiStripped = stripOpenAIHistoryTransforms(geminiResult.messages, modelString);
+  if (openaiStripped !== geminiResult.messages && apiLogOn) {
+    logApiEvent("openai history transforms applied", { modelString });
+  }
+  const normalised = normalizeOpenAICompatibleToolCallInputs(openaiStripped, modelString);
+  if (normalised !== openaiStripped && apiLogOn) {
+    logApiEvent("openai-compatible tool input normalized", { modelString });
+  }
+  const preStats = apiLogOn ? getMessageDiagnostics(normalised) : getMessageStats(normalised);
+  if (apiLogOn)
+    logApiEvent("turn context pre-prune", preStats);
+  const pruned = applyContextPruning(normalised, pruningMode);
+  const postStats = apiLogOn ? getMessageDiagnostics(pruned) : getMessageStats(pruned);
+  if (apiLogOn)
+    logApiEvent("turn context post-prune", postStats);
+  const compacted = compactToolResultPayloads(pruned, toolResultPayloadCapBytes);
+  if (compacted !== pruned && apiLogOn) {
+    logApiEvent("turn context post-compaction", {
+      capBytes: toolResultPayloadCapBytes,
+      diagnostics: getMessageDiagnostics(compacted)
+    });
+  }
+  let finalMessages = compacted;
+  let finalSystemPrompt = systemPrompt;
+  const cacheFamily = getCacheFamily(modelString);
+  if (cacheFamily === "anthropic" && promptCachingEnabled) {
+    const annotated = annotateAnthropicCacheBreakpoints(compacted, systemPrompt);
+    finalMessages = annotated.messages;
+    finalSystemPrompt = annotated.systemPrompt;
+    if (apiLogOn) {
+      logApiEvent("Anthropic prompt caching", annotated.diagnostics);
+    }
+  }
+  if (isAnthropicModelFamily(modelString) && isAnthropicOAuth()) {
+    const prefix = `You are Claude Code, Anthropic's official CLI for Claude.
+`;
+    if (finalSystemPrompt) {
+      finalSystemPrompt = prefix + finalSystemPrompt;
+    } else {
+      const sysMsg = finalMessages.find((m) => m.role === "system");
+      if (sysMsg && typeof sysMsg.content === "string") {
+        const idx = finalMessages.indexOf(sysMsg);
+        finalMessages[idx] = { ...sysMsg, content: prefix + sysMsg.content };
+      }
+    }
+  }
+  const wasPruned = (pruningMode === "balanced" || pruningMode === "aggressive") && (postStats.messageCount < preStats.messageCount || postStats.totalBytes < preStats.totalBytes);
+  return {
+    messages: finalMessages,
+    systemPrompt: finalSystemPrompt,
+    pruned: wasPruned,
+    prePruneMessageCount: preStats.messageCount,
+    prePruneTotalBytes: preStats.totalBytes,
+    postPruneMessageCount: postStats.messageCount,
+    postPruneTotalBytes: postStats.totalBytes
+  };
 }
 
-class StreamTextPhaseTracker {
-  phaseByTextPartId = new Map;
-  sawExplicitReasoningThisStep = false;
-  route(chunk) {
-    const textPartId = normalizeTextPartId(chunk.id);
-    switch (chunk.type) {
-      case "start-step": {
-        this.sawExplicitReasoningThisStep = false;
-        return "text";
+// src/llm-api/turn-provider-options.ts
+function isRecord5(value) {
+  return value !== null && typeof value === "object";
+}
+function mergeDeep(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    const sVal = source[key];
+    const tVal = target[key];
+    output[key] = isRecord5(sVal) && isRecord5(tVal) ? { ...tVal, ...sVal } : sVal;
+  }
+  return output;
+}
+function buildTurnProviderOptions(input) {
+  const {
+    modelString,
+    thinkingEffort,
+    promptCachingEnabled,
+    openaiPromptCacheRetention,
+    googleCachedContent,
+    toolCount,
+    hasSystemPrompt
+  } = input;
+  const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
+  const reasoningSummaryRequested = isRecord5(thinkingOpts) && isRecord5(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
+  const cacheFamily = getCacheFamily(modelString);
+  const cacheOpts = getCachingProviderOptions(modelString, {
+    enabled: promptCachingEnabled,
+    openaiRetention: openaiPromptCacheRetention,
+    googleCachedContent,
+    googleExplicitCachingCompatible: toolCount === 0 && !hasSystemPrompt
+  });
+  const baseProviderOpts = {
+    ...thinkingOpts ?? {},
+    ...isOpenAIGPT(modelString) ? {
+      openai: {
+        store: false,
+        ...isRecord5(thinkingOpts?.openai) ? thinkingOpts.openai : {}
+      }
+    } : {}
+  };
+  const providerOptions = cacheOpts ? mergeDeep(baseProviderOpts, cacheOpts) : baseProviderOpts;
+  return {
+    cacheFamily,
+    thinkingOpts,
+    cacheOpts,
+    providerOptions,
+    reasoningSummaryRequested
+  };
+}
+
+// src/llm-api/turn-request.ts
+function buildTurnPreparation(input) {
+  const providerOptionsResult = buildTurnProviderOptions({
+    modelString: input.modelString,
+    thinkingEffort: input.thinkingEffort,
+    promptCachingEnabled: input.promptCachingEnabled,
+    openaiPromptCacheRetention: input.openaiPromptCacheRetention,
+    googleCachedContent: input.googleCachedContent,
+    toolCount: input.toolCount,
+    hasSystemPrompt: Boolean(input.systemPrompt)
+  });
+  const prepared = prepareTurnMessages({
+    messages: input.messages,
+    modelString: input.modelString,
+    toolCount: input.toolCount,
+    systemPrompt: input.systemPrompt,
+    pruningMode: input.pruningMode,
+    toolResultPayloadCapBytes: input.toolResultPayloadCapBytes,
+    promptCachingEnabled: input.promptCachingEnabled
+  });
+  return { providerOptionsResult, prepared };
+}
+function buildStreamTextRequest(input) {
+  return {
+    model: input.model,
+    maxOutputTokens: 16384,
+    messages: input.prepared.messages,
+    tools: input.toolSet,
+    stopWhen: stepCountIs(input.maxSteps),
+    onStepFinish: input.onStepFinish,
+    prepareStep: ({ stepNumber }) => {
+      if (stepNumber >= input.maxSteps - 1) {
+        return { activeTools: [] };
+      }
+      return;
+    },
+    ...input.prepared.systemPrompt ? { system: input.prepared.systemPrompt } : {},
+    ...Object.keys(input.providerOptions).length > 0 ? {
+      providerOptions: input.providerOptions
+    } : {},
+    ...input.signal ? { abortSignal: input.signal } : {},
+    onError: () => {},
+    timeout: { chunkMs: 120000 }
+  };
+}
+
+// src/llm-api/turn-anthropic-oauth.ts
+var MAX_STEPS = 50;
+var MAX_OUTPUT_TOKENS = 16384;
+var CC_VERSION = "2.1.75";
+var cachedClient = null;
+function getClient(token) {
+  if (cachedClient?.token === token && cachedClient.client)
+    return cachedClient.client;
+  const client = new Anthropic({
+    apiKey: null,
+    authToken: token,
+    maxRetries: 5,
+    dangerouslyAllowBrowser: true,
+    defaultHeaders: {
+      accept: "application/json",
+      "anthropic-dangerous-direct-browser-access": "true",
+      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+      "user-agent": `claude-cli/${CC_VERSION}`,
+      "x-app": "cli"
+    }
+  });
+  cachedClient = { token, client };
+  return client;
+}
+function supportsAdaptiveThinking(modelId) {
+  return modelId.includes("opus-4-6") || modelId.includes("sonnet-4-6");
+}
+function mapEffort(effort, modelId) {
+  if (!effort)
+    return;
+  const map = {
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: modelId.includes("opus-4-6") ? "max" : "high"
+  };
+  return map[effort];
+}
+function coreToAnthropicMessages(messages) {
+  let systemPrompt;
+  const params = [];
+  const toolUseIds = new Set;
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content))
+      continue;
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && part.toolCallId) {
+        toolUseIds.add(part.toolCallId);
+      }
+    }
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemPrompt = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join(`
+`) : undefined;
+      continue;
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        if (msg.content.trim())
+          params.push({ role: "user", content: msg.content });
+        continue;
+      }
+      if (Array.isArray(msg.content)) {
+        const blocks = [];
+        for (const part of msg.content) {
+          if (part.type === "text" && part.text?.trim()) {
+            blocks.push({ type: "text", text: part.text });
+          } else if (part.type === "tool-result") {
+            if (!toolUseIds.has(part.toolCallId))
+              continue;
+            blocks.push({
+              type: "tool_result",
+              tool_use_id: part.toolCallId,
+              content: typeof part.result === "string" ? part.result : JSON.stringify(part.result ?? part.output ?? ""),
+              is_error: part.isError ?? false
+            });
+          } else if (part.type === "image") {
+            blocks.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: part.mimeType ?? "image/png",
+                data: part.data
+              }
+            });
+          }
+        }
+        if (blocks.length > 0)
+          params.push({ role: "user", content: blocks });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        if (msg.content.trim())
+          params.push({ role: "assistant", content: msg.content });
+        continue;
+      }
+      if (Array.isArray(msg.content)) {
+        const blocks = [];
+        for (const part of msg.content) {
+          if (part.type === "text" && part.text?.trim()) {
+            blocks.push({ type: "text", text: part.text });
+          } else if (part.type === "tool-call") {
+            blocks.push({
+              type: "tool_use",
+              id: part.toolCallId,
+              name: part.toolName,
+              input: part.args ?? {}
+            });
+          } else if (part.type === "thinking") {
+            if (part.redacted && part.signature) {
+              blocks.push({
+                type: "redacted_thinking",
+                data: part.signature
+              });
+            } else if (part.text?.trim() && part.signature?.trim()) {
+              blocks.push({
+                type: "thinking",
+                thinking: part.text,
+                signature: part.signature
+              });
+            }
+          }
+        }
+        if (blocks.length > 0)
+          params.push({ role: "assistant", content: blocks });
+      }
+    }
+  }
+  return { system: systemPrompt, params };
+}
+function convertTools(tools) {
+  return tools.map((tool) => {
+    const schema = zodSchema(tool.schema).jsonSchema;
+    return {
+      name: tool.name,
+      description: tool.description,
+      input_schema: {
+        type: "object",
+        properties: schema.properties ?? {},
+        required: schema.required ?? []
+      }
+    };
+  });
+}
+function buildCoreMessages(assistantText, thinkingBlocks, toolCalls, toolResults) {
+  const messages = [];
+  const parts = [];
+  for (const tb of thinkingBlocks) {
+    if (tb.redacted) {
+      parts.push({
+        type: "thinking",
+        text: "[Reasoning redacted]",
+        signature: tb.signature,
+        redacted: true
+      });
+    } else {
+      parts.push({
+        type: "thinking",
+        text: tb.text,
+        signature: tb.signature
+      });
+    }
+  }
+  if (assistantText.trim()) {
+    parts.push({ type: "text", text: assistantText });
+  }
+  for (const tc of toolCalls) {
+    parts.push({
+      type: "tool-call",
+      toolCallId: tc.id,
+      toolName: tc.name,
+      args: tc.args
+    });
+  }
+  if (parts.length > 0) {
+    messages.push({
+      role: "assistant",
+      content: parts
+    });
+  }
+  if (toolResults.length > 0) {
+    const resultParts = toolResults.map((tr) => ({
+      type: "tool-result",
+      toolCallId: tr.toolCallId,
+      toolName: tr.toolName,
+      result: tr.result,
+      isError: tr.isError
+    }));
+    messages.push({
+      role: "user",
+      content: resultParts
+    });
+  }
+  return messages;
+}
+function parseStreamingJson(partial) {
+  try {
+    return JSON.parse(partial);
+  } catch {
+    try {
+      let fixed = partial;
+      const opens = (fixed.match(/{/g) || []).length;
+      const closes = (fixed.match(/}/g) || []).length;
+      for (let i = 0;i < opens - closes; i++)
+        fixed += "}";
+      return JSON.parse(fixed);
+    } catch {
+      return {};
+    }
+  }
+}
+async function* runTurnAnthropicOAuth(options) {
+  const {
+    token,
+    modelString,
+    messages,
+    tools,
+    systemPrompt,
+    signal,
+    thinkingEffort,
+    pruningMode = "balanced",
+    promptCachingEnabled = true,
+    toolResultPayloadCapBytes = DEFAULT_TOOL_RESULT_PAYLOAD_CAP_BYTES
+  } = options;
+  const modelId = modelString.replace(/^anthropic\//, "");
+  const client = getClient(token);
+  const anthropicTools = convertTools(tools);
+  const toolExecutors = new Map(tools.map((t) => [t.name, t.execute]));
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let contextTokens = 0;
+  let stepCount = 0;
+  const allNewMessages = [];
+  try {
+    const { prepared } = buildTurnPreparation({
+      modelString,
+      messages,
+      thinkingEffort,
+      promptCachingEnabled,
+      openaiPromptCacheRetention: "in_memory",
+      googleCachedContent: null,
+      toolCount: tools.length,
+      systemPrompt,
+      pruningMode,
+      toolResultPayloadCapBytes
+    });
+    logApiEvent("turn start", {
+      modelString,
+      messageCount: messages.length,
+      reasoningSummaryRequested: false,
+      pruningMode,
+      toolResultPayloadCapBytes
+    });
+    if (prepared.pruned) {
+      yield {
+        type: "context-pruned",
+        mode: pruningMode,
+        beforeMessageCount: prepared.prePruneMessageCount,
+        afterMessageCount: prepared.postPruneMessageCount,
+        removedMessageCount: prepared.prePruneMessageCount - prepared.postPruneMessageCount,
+        beforeTotalBytes: prepared.prePruneTotalBytes,
+        afterTotalBytes: prepared.postPruneTotalBytes,
+        removedBytes: prepared.prePruneTotalBytes - prepared.postPruneTotalBytes
+      };
+    }
+    const { system: extractedSystem, params: anthropicMessages } = coreToAnthropicMessages(prepared.messages);
+    const ccPrefix = "You are Claude Code, Anthropic's official CLI for Claude.";
+    const sysText = prepared.systemPrompt ?? extractedSystem;
+    const systemBlocks = [
+      {
+        type: "text",
+        text: ccPrefix,
+        cache_control: { type: "ephemeral" }
       }
-      case "reasoning-start":
-      case "reasoning-delta":
-      case "reasoning-end":
-      case "reasoning": {
-        this.sawExplicitReasoningThisStep = true;
-        return "text";
+    ];
+    if (sysText) {
+      const clean = sysText.startsWith(ccPrefix) ? sysText.slice(ccPrefix.length).replace(/^\n/, "") : sysText;
+      if (clean.trim()) {
+        systemBlocks.push({
+          type: "text",
+          text: clean,
+          cache_control: { type: "ephemeral" }
+        });
       }
-      case "text-start": {
-        const phase = getOpenAITextPhase2(chunk);
-        if (textPartId && phase)
-          this.phaseByTextPartId.set(textPartId, phase);
-        return "skip";
+    }
+    const currentMessages = [...anthropicMessages];
+    while (stepCount < MAX_STEPS) {
+      stepCount++;
+      const isLastStep = stepCount >= MAX_STEPS;
+      const params = {
+        model: modelId,
+        max_tokens: MAX_OUTPUT_TOKENS,
+        system: systemBlocks,
+        messages: currentMessages,
+        tools: isLastStep ? [] : anthropicTools,
+        stream: true
+      };
+      if (thinkingEffort && supportsAdaptiveThinking(modelId)) {
+        params.thinking = { type: "adaptive" };
+        const effort = mapEffort(thinkingEffort, modelId);
+        if (effort) {
+          params.output_config = {
+            effort
+          };
+        }
       }
-      case "text-end": {
-        if (textPartId)
-          this.phaseByTextPartId.delete(textPartId);
-        return "skip";
+      for (const m of currentMessages) {
+        if (!Array.isArray(m.content))
+          continue;
+        for (const block of m.content) {
+          if (typeof block === "object" && block !== null) {
+            delete block.cache_control;
+          }
+        }
       }
-      case "text-delta": {
-        if (!textPartId)
-          return "text";
-        if (this.phaseByTextPartId.get(textPartId) !== "commentary") {
-          return "text";
+      const lastMsg = currentMessages.length > 0 ? currentMessages[currentMessages.length - 1] : undefined;
+      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
+        const lastBlock = lastMsg.content[lastMsg.content.length - 1];
+        if (lastBlock && typeof lastBlock === "object") {
+          lastBlock.cache_control = {
+            type: "ephemeral"
+          };
         }
-        return this.sawExplicitReasoningThisStep ? "skip" : "reasoning";
       }
-      default:
-        return "text";
+      if (isApiLogEnabled()) {
+        logApiEvent("Provider Request", {
+          url: "https://api.anthropic.com/v1/messages",
+          method: "POST",
+          model: modelId,
+          messageCount: currentMessages.length,
+          toolCount: params.tools?.length ?? 0
+        });
+      }
+      const stream = client.messages.stream(params, { signal });
+      let assistantText = "";
+      const thinkingBlocks = [];
+      const toolCalls = [];
+      let partialJson = "";
+      let currentToolId = "";
+      let currentToolName = "";
+      let stepInputTokens = 0;
+      let stepOutputTokens = 0;
+      let stopReason;
+      for await (const event of stream) {
+        if (event.type === "message_start") {
+          stepInputTokens = event.message.usage.input_tokens || 0;
+          stepOutputTokens = event.message.usage.output_tokens || 0;
+        } else if (event.type === "content_block_start") {
+          if (event.content_block.type === "text") {} else if (event.content_block.type === "thinking") {
+            thinkingBlocks.push({
+              text: "",
+              signature: ""
+            });
+          } else if (event.content_block.type === "redacted_thinking") {
+            thinkingBlocks.push({
+              text: "[Reasoning redacted]",
+              signature: event.content_block.data,
+              redacted: true
+            });
+          } else if (event.content_block.type === "tool_use") {
+            currentToolId = event.content_block.id;
+            currentToolName = event.content_block.name;
+            partialJson = "";
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            assistantText += event.delta.text;
+            yield { type: "text-delta", delta: event.delta.text };
+          } else if (event.delta.type === "thinking_delta") {
+            const tb = thinkingBlocks[thinkingBlocks.length - 1];
+            if (tb)
+              tb.text += event.delta.thinking;
+            yield {
+              type: "reasoning-delta",
+              delta: event.delta.thinking
+            };
+          } else if (event.delta.type === "input_json_delta") {
+            partialJson += event.delta.partial_json;
+          } else if (event.delta.type === "signature_delta") {
+            const tb = thinkingBlocks[thinkingBlocks.length - 1];
+            if (tb)
+              tb.signature += event.delta.signature;
+          }
+        } else if (event.type === "content_block_stop") {
+          if (currentToolId && currentToolName) {
+            const args = parseStreamingJson(partialJson);
+            toolCalls.push({
+              id: currentToolId,
+              name: currentToolName,
+              args
+            });
+            yield {
+              type: "tool-call-start",
+              toolCallId: currentToolId,
+              toolName: currentToolName,
+              args
+            };
+            currentToolId = "";
+            currentToolName = "";
+            partialJson = "";
+          }
+        } else if (event.type === "message_delta") {
+          if (event.delta.stop_reason) {
+            stopReason = event.delta.stop_reason;
+          }
+          if (event.usage.output_tokens != null) {
+            stepOutputTokens = event.usage.output_tokens;
+          }
+        }
+      }
+      totalInputTokens += stepInputTokens;
+      totalOutputTokens += stepOutputTokens;
+      contextTokens = stepInputTokens;
+      logApiEvent("step finish", {
+        stepNumber: stepCount,
+        finishReason: stopReason,
+        usage: {
+          inputTokens: stepInputTokens,
+          outputTokens: stepOutputTokens
+        }
+      });
+      const toolResults = [];
+      if (stopReason === "tool_use" && toolCalls.length > 0) {
+        for (const tc of toolCalls) {
+          const executor = toolExecutors.get(tc.name);
+          let result;
+          let isError = false;
+          if (!executor) {
+            result = `Unknown tool: ${tc.name}`;
+            isError = true;
+          } else {
+            try {
+              result = await executor(tc.args);
+            } catch (err) {
+              result = normalizeUnknownError(err).message;
+              isError = true;
+            }
+          }
+          toolResults.push({
+            toolCallId: tc.id,
+            toolName: tc.name,
+            result,
+            isError
+          });
+          yield {
+            type: "tool-result",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            result,
+            isError
+          };
+        }
+      }
+      const stepMessages = buildCoreMessages(assistantText, thinkingBlocks, toolCalls, toolResults);
+      allNewMessages.push(...stepMessages);
+      if (stopReason !== "tool_use" || toolCalls.length === 0) {
+        break;
+      }
+      const assistantBlocks = [];
+      for (const tb of thinkingBlocks) {
+        if (tb.redacted) {
+          assistantBlocks.push({
+            type: "redacted_thinking",
+            data: tb.signature
+          });
+        } else if (tb.text.trim() && tb.signature.trim()) {
+          assistantBlocks.push({
+            type: "thinking",
+            thinking: tb.text,
+            signature: tb.signature
+          });
+        }
+      }
+      if (assistantText.trim()) {
+        assistantBlocks.push({ type: "text", text: assistantText });
+      }
+      for (const tc of toolCalls) {
+        assistantBlocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: tc.args
+        });
+      }
+      currentMessages.push({
+        role: "assistant",
+        content: assistantBlocks
+      });
+      const resultBlocks = toolResults.map((tr) => ({
+        type: "tool_result",
+        tool_use_id: tr.toolCallId,
+        content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result ?? ""),
+        is_error: tr.isError
+      }));
+      currentMessages.push({ role: "user", content: resultBlocks });
     }
+    logApiEvent("turn complete", {
+      newMessagesCount: allNewMessages.length,
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    });
+    yield {
+      type: "turn-complete",
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens,
+      contextTokens,
+      messages: allNewMessages
+    };
+  } catch (err) {
+    const normalizedError = normalizeUnknownError(err);
+    logApiEvent("turn error", normalizedError);
+    yield {
+      type: "turn-error",
+      error: normalizedError,
+      partialMessages: allNewMessages
+    };
   }
 }
-function mapCommentaryChunkToTurnEvent(chunk) {
-  if (chunk.type !== "text-delta")
-    return null;
-  return {
-    type: "reasoning-delta",
-    delta: extractTextDelta(chunk)
-  };
-}
 
-class StreamToolCallTracker {
-  syntheticCount = 0;
-  pendingByTool = new Map;
-  deferredStartsByTool = new Map;
-  prepare(chunk) {
-    const type = chunk.type;
-    if (!type) {
-      return { chunk, suppressTurnEvent: false };
-    }
-    if (type === "tool-input-start") {
-      const toolName = normalizeToolName(chunk.toolName);
-      const toolCallId = normalizeToolCallId(chunk.toolCallId);
-      const args = extractToolArgs(chunk);
-      if (!hasRenderableToolArgs(args)) {
-        if (!toolCallId) {
-          this.trackDeferredStart(toolName);
-          return { chunk, suppressTurnEvent: true };
-        }
-        return { chunk, suppressTurnEvent: false };
-      }
+// src/llm-api/turn-execution.ts
+import { dynamicTool, jsonSchema } from "ai";
+
+// src/llm-api/turn-stream-events.ts
+function shouldLogStreamChunk(c11) {
+  return c11.type !== "text-delta" && c11.type !== "reasoning" && c11.type !== "reasoning-delta";
+}
+function extractToolArgs(c11) {
+  return c11.input ?? c11.args;
+}
+function hasRenderableToolArgs(args) {
+  if (args === null || args === undefined)
+    return false;
+  if (typeof args === "string")
+    return args.trim().length > 0;
+  if (Array.isArray(args))
+    return args.length > 0;
+  if (typeof args === "object")
+    return Object.keys(args).length > 0;
+  return true;
+}
+function mapStreamChunkToTurnEvent(c11) {
+  switch (c11.type) {
+    case "text-delta": {
+      const delta = typeof c11.text === "string" ? c11.text : "";
       return {
-        chunk: this.trackRenderableStart(chunk, toolName, toolCallId),
-        suppressTurnEvent: false
+        type: "text-delta",
+        delta
       };
     }
-    if (type === "tool-call") {
-      const toolName = normalizeToolName(chunk.toolName);
-      this.consumeDeferredStart(toolName);
+    case "reasoning-delta":
+    case "reasoning": {
+      const delta = getReasoningDeltaFromStreamChunk(c11);
+      if (delta === null)
+        return null;
       return {
-        chunk: this.trackRenderableStart(chunk, toolName, normalizeToolCallId(chunk.toolCallId)),
-        suppressTurnEvent: false
+        type: "reasoning-delta",
+        delta
       };
     }
-    if (TOOL_RESULT_CHUNK_TYPES.has(type)) {
-      const toolName = normalizeToolName(chunk.toolName);
-      const existingToolCallId = normalizeToolCallId(chunk.toolCallId);
-      if (existingToolCallId) {
-        this.consumeTracked(toolName, existingToolCallId);
-        return { chunk, suppressTurnEvent: false };
-      }
-      const nextToolCallId = this.consumeNextTracked(toolName) ?? this.nextSyntheticToolCallId();
+    case "tool-input-start": {
+      const args = extractToolArgs(c11);
+      const hasStableToolCallId = typeof c11.toolCallId === "string" && c11.toolCallId.trim().length > 0;
+      if (hasStableToolCallId && !hasRenderableToolArgs(args))
+        return null;
       return {
-        chunk: { ...chunk, toolCallId: nextToolCallId },
-        suppressTurnEvent: false
+        type: "tool-call-start",
+        toolCallId: String(c11.toolCallId ?? ""),
+        toolName: String(c11.toolName ?? ""),
+        args
       };
     }
-    return { chunk, suppressTurnEvent: false };
-  }
-  trackRenderableStart(chunk, toolName, existingToolCallId) {
-    const toolCallId = existingToolCallId ?? this.nextSyntheticToolCallId();
-    this.trackStart(toolName, toolCallId);
-    if (toolCallId === chunk.toolCallId)
-      return chunk;
-    return { ...chunk, toolCallId };
-  }
-  nextSyntheticToolCallId() {
-    this.syntheticCount += 1;
-    return `synthetic-tool-call-${this.syntheticCount}`;
-  }
-  trackStart(toolName, toolCallId) {
-    const pending = this.pendingByTool.get(toolName) ?? [];
-    pending.push(toolCallId);
-    this.pendingByTool.set(toolName, pending);
-  }
-  trackDeferredStart(toolName) {
-    this.deferredStartsByTool.set(toolName, (this.deferredStartsByTool.get(toolName) ?? 0) + 1);
-  }
-  consumeDeferredStart(toolName) {
-    const count = this.deferredStartsByTool.get(toolName) ?? 0;
-    if (count <= 0)
-      return;
-    if (count === 1) {
-      this.deferredStartsByTool.delete(toolName);
-      return;
+    case "tool-call": {
+      return {
+        type: "tool-call-start",
+        toolCallId: String(c11.toolCallId ?? ""),
+        toolName: String(c11.toolName ?? ""),
+        args: extractToolArgs(c11)
+      };
     }
-    this.deferredStartsByTool.set(toolName, count - 1);
-  }
-  consumeTracked(toolName, toolCallId) {
-    const pending = this.pendingByTool.get(toolName);
-    if (!pending || pending.length === 0)
-      return;
-    const idx = pending.indexOf(toolCallId);
-    if (idx === -1)
-      return;
-    pending.splice(idx, 1);
-    if (pending.length === 0)
-      this.pendingByTool.delete(toolName);
-  }
-  consumeNextTracked(toolName) {
-    const pending = this.pendingByTool.get(toolName);
-    if (!pending || pending.length === 0)
-      return null;
-    const toolCallId = pending.shift() ?? null;
-    if (pending.length === 0)
-      this.pendingByTool.delete(toolName);
-    return toolCallId;
-  }
-}
-async function* mapFullStreamToTurnEvents(stream, opts) {
-  const toolCallTracker = new StreamToolCallTracker;
-  const textPhaseTracker = new StreamTextPhaseTracker;
-  for await (const originalChunk of stream) {
-    const prepared = toolCallTracker.prepare(originalChunk);
-    const chunk = prepared.chunk;
-    const route = textPhaseTracker.route(chunk);
-    if (!prepared.suppressTurnEvent && route !== "skip" && shouldLogStreamChunk(chunk)) {
-      opts.onChunk?.(chunk);
+    case "tool-result": {
+      return {
+        type: "tool-result",
+        toolCallId: String(c11.toolCallId ?? ""),
+        toolName: String(c11.toolName ?? ""),
+        result: "output" in c11 ? c11.output : ("result" in c11) ? c11.result : undefined,
+        isError: "isError" in c11 ? Boolean(c11.isError) : false
+      };
     }
-    if (prepared.suppressTurnEvent || route === "skip")
-      continue;
-    const event = route === "reasoning" ? mapCommentaryChunkToTurnEvent(chunk) : mapStreamChunkToTurnEvent(chunk);
-    if (event)
-      yield event;
+    case "tool-error":
+      return {
+        type: "tool-result",
+        toolCallId: String(c11.toolCallId ?? ""),
+        toolName: String(c11.toolName ?? ""),
+        result: c11.error ?? "Tool execution failed",
+        isError: true
+      };
+    case "error": {
+      throw normalizeUnknownError(c11.error);
+    }
+    default:
+      return null;
   }
 }
 
-// src/llm-api/turn-request.ts
-import { stepCountIs } from "ai";
-
-// src/llm-api/provider-options.ts
-var ANTHROPIC_BUDGET = {
-  low: 4096,
-  medium: 8192,
-  high: 16384,
-  xhigh: 32768
-};
-var GEMINI_BUDGET = {
-  low: 4096,
-  medium: 8192,
-  high: 16384,
-  xhigh: 24575
-};
-function clampEffort(effort, max) {
-  const ORDER = ["low", "medium", "high", "xhigh"];
-  const effortIdx = ORDER.indexOf(effort);
-  const maxIdx = ORDER.indexOf(max);
-  return ORDER[Math.min(effortIdx, maxIdx)];
+// src/llm-api/turn-execution.ts
+function isZodSchema(s) {
+  return s !== null && typeof s === "object" && "_def" in s;
 }
-function getAnthropicThinkingOptions(modelId, effort) {
-  const isAdaptive = /^claude-3-7/.test(modelId) || /^claude-sonnet-4/.test(modelId) || /^claude-opus-4/.test(modelId);
-  if (isAdaptive) {
-    const isOpus = /^claude-opus-4/.test(modelId);
-    const mapped = effort === "xhigh" ? isOpus ? "max" : "high" : effort;
-    return { anthropic: { thinking: { type: "adaptive" }, effort: mapped } };
-  }
-  return {
-    anthropic: {
-      thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET[effort] },
-      betas: ["interleaved-thinking-2025-05-14"]
+function toCoreTool(def) {
+  const schema = isZodSchema(def.schema) ? def.schema : jsonSchema(def.schema);
+  return dynamicTool({
+    description: def.description,
+    inputSchema: schema,
+    execute: async (input) => {
+      try {
+        return await def.execute(input);
+      } catch (err) {
+        throw normalizeUnknownError(err);
+      }
     }
-  };
-}
-function getOpenAIThinkingOptions(modelId, effort) {
-  const supportsXhigh = /^gpt-5\.[2-9]/.test(modelId) || /^o4/.test(modelId);
-  const clamped = supportsXhigh ? effort : clampEffort(effort, "high");
-  return { openai: { reasoningEffort: clamped, reasoningSummary: "auto" } };
+  });
 }
-function getGeminiThinkingOptions(modelId, effort) {
-  if (/^gemini-3/.test(modelId)) {
-    return {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingLevel: clampEffort(effort, "high")
-        }
-      }
-    };
+function buildToolSet(tools) {
+  const toolSet = {};
+  for (const def of tools) {
+    toolSet[def.name] = toCoreTool(def);
   }
+  return toolSet;
+}
+function createTurnStepTracker(opts) {
+  let stepCount = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let contextTokens = 0;
+  let partialMessages = [];
   return {
-    google: {
-      thinkingConfig: {
-        includeThoughts: true,
-        thinkingBudget: GEMINI_BUDGET[effort]
-      }
-    }
+    onStepFinish: (step) => {
+      opts.onStepLog({
+        stepNumber: stepCount + 1,
+        finishReason: step.finishReason,
+        usage: step.usage
+      });
+      inputTokens += step.usage?.inputTokens ?? 0;
+      outputTokens += step.usage?.outputTokens ?? 0;
+      contextTokens = step.usage?.inputTokens ?? contextTokens;
+      stepCount += 1;
+      const s = step;
+      partialMessages = s.response?.messages ?? s.messages ?? partialMessages;
+    },
+    getState: () => ({
+      stepCount,
+      inputTokens,
+      outputTokens,
+      contextTokens,
+      partialMessages
+    })
   };
 }
-var THINKING_STRATEGIES = [
-  {
-    supports: isAnthropicModelFamily,
-    build: getAnthropicThinkingOptions
-  },
-  {
-    supports: isOpenAIReasoningModelFamily,
-    build: getOpenAIThinkingOptions
-  },
-  {
-    supports: isGeminiModelFamily,
-    build: getGeminiThinkingOptions
-  }
-];
-function getThinkingProviderOptions(modelString, effort) {
-  if (!supportsThinking(modelString))
+var TOOL_RESULT_CHUNK_TYPES = new Set(["tool-result", "tool-error"]);
+function normalizeToolCallId(raw) {
+  if (typeof raw !== "string")
     return null;
-  const { modelId } = parseModelString(modelString);
-  for (const strategy of THINKING_STRATEGIES) {
-    if (!strategy.supports(modelString))
-      continue;
-    return strategy.build(modelId, effort);
-  }
-  return null;
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : null;
 }
-var CACHE_FAMILY_RULES = [
-  [isAnthropicModelFamily, "anthropic"],
-  [isGeminiModelFamily, "google"]
-];
-function getCacheFamily(modelString) {
-  for (const [match, family] of CACHE_FAMILY_RULES) {
-    if (match(modelString))
-      return family;
-  }
-  return "none";
+function normalizeToolName(raw) {
+  if (typeof raw !== "string")
+    return "tool";
+  const trimmed = raw.trim();
+  return trimmed || "tool";
 }
-function getCachingProviderOptions(modelString, opts) {
-  if (!opts.enabled)
+function isRecord6(value) {
+  return value !== null && typeof value === "object";
+}
+function normalizeTextPartId(raw) {
+  if (typeof raw !== "string")
     return null;
-  const family = getCacheFamily(modelString);
-  if (family === "google" && opts.googleCachedContent && opts.googleExplicitCachingCompatible !== false) {
-    return { google: { cachedContent: opts.googleCachedContent } };
-  }
-  return null;
+  const trimmed = raw.trim();
+  return trimmed ? trimmed : null;
 }
-
-// src/llm-api/turn-prepare-messages.ts
-function prepareTurnMessages(input) {
-  const {
-    messages,
-    modelString,
-    toolCount,
-    systemPrompt,
-    pruningMode,
-    toolResultPayloadCapBytes,
-    promptCachingEnabled
-  } = input;
-  const apiLogOn = isApiLogEnabled();
-  const strippedRuntimeToolFields = stripToolRuntimeInputFields(messages);
-  if (strippedRuntimeToolFields !== messages && apiLogOn) {
-    logApiEvent("runtime tool input fields stripped", { modelString });
-  }
-  const geminiResult = sanitizeGeminiToolMessagesWithMetadata(strippedRuntimeToolFields, modelString, toolCount > 0);
-  if (geminiResult.repaired && apiLogOn) {
-    logApiEvent("gemini tool history repaired", {
-      modelString,
-      reason: geminiResult.reason,
-      repairedFromIndex: geminiResult.repairedFromIndex,
-      droppedMessageCount: geminiResult.droppedMessageCount,
-      tailOnlyAffected: geminiResult.tailOnlyAffected
-    });
-  }
-  const openaiStripped = stripOpenAIHistoryTransforms(geminiResult.messages, modelString);
-  if (openaiStripped !== geminiResult.messages && apiLogOn) {
-    logApiEvent("openai history transforms applied", { modelString });
-  }
-  const normalised = normalizeOpenAICompatibleToolCallInputs(openaiStripped, modelString);
-  if (normalised !== openaiStripped && apiLogOn) {
-    logApiEvent("openai-compatible tool input normalized", { modelString });
-  }
-  const preStats = apiLogOn ? getMessageDiagnostics(normalised) : getMessageStats(normalised);
-  if (apiLogOn)
-    logApiEvent("turn context pre-prune", preStats);
-  const pruned = applyContextPruning(normalised, pruningMode);
-  const postStats = apiLogOn ? getMessageDiagnostics(pruned) : getMessageStats(pruned);
-  if (apiLogOn)
-    logApiEvent("turn context post-prune", postStats);
-  const compacted = compactToolResultPayloads(pruned, toolResultPayloadCapBytes);
-  if (compacted !== pruned && apiLogOn) {
-    logApiEvent("turn context post-compaction", {
-      capBytes: toolResultPayloadCapBytes,
-      diagnostics: getMessageDiagnostics(compacted)
-    });
-  }
-  let finalMessages = compacted;
-  let finalSystemPrompt = systemPrompt;
-  const cacheFamily = getCacheFamily(modelString);
-  if (cacheFamily === "anthropic" && promptCachingEnabled) {
-    const annotated = annotateAnthropicCacheBreakpoints(compacted, systemPrompt);
-    finalMessages = annotated.messages;
-    finalSystemPrompt = annotated.systemPrompt;
-    if (apiLogOn) {
-      logApiEvent("Anthropic prompt caching", annotated.diagnostics);
-    }
-  }
-  const wasPruned = (pruningMode === "balanced" || pruningMode === "aggressive") && (postStats.messageCount < preStats.messageCount || postStats.totalBytes < preStats.totalBytes);
-  return {
-    messages: finalMessages,
-    systemPrompt: finalSystemPrompt,
-    pruned: wasPruned,
-    prePruneMessageCount: preStats.messageCount,
-    prePruneTotalBytes: preStats.totalBytes,
-    postPruneMessageCount: postStats.messageCount,
-    postPruneTotalBytes: postStats.totalBytes
-  };
+function getOpenAITextPhase2(chunk) {
+  const providerData = isRecord6(chunk.providerMetadata) ? chunk.providerMetadata : isRecord6(chunk.providerOptions) ? chunk.providerOptions : null;
+  if (!providerData)
+    return null;
+  const openai = providerData.openai;
+  if (!isRecord6(openai))
+    return null;
+  return openai.phase === "commentary" || openai.phase === "final_answer" ? openai.phase : null;
 }
-
-// src/llm-api/turn-provider-options.ts
-function isRecord6(value) {
-  return value !== null && typeof value === "object";
+function extractTextDelta(chunk) {
+  if (typeof chunk.text === "string")
+    return chunk.text;
+  if (typeof chunk.textDelta === "string")
+    return chunk.textDelta;
+  if (typeof chunk.delta === "string")
+    return chunk.delta;
+  return "";
 }
-function mergeDeep(target, source) {
-  const output = { ...target };
-  for (const key in source) {
-    const sVal = source[key];
-    const tVal = target[key];
-    output[key] = isRecord6(sVal) && isRecord6(tVal) ? { ...tVal, ...sVal } : sVal;
+
+class StreamTextPhaseTracker {
+  phaseByTextPartId = new Map;
+  sawExplicitReasoningThisStep = false;
+  route(chunk) {
+    const textPartId = normalizeTextPartId(chunk.id);
+    switch (chunk.type) {
+      case "start-step": {
+        this.sawExplicitReasoningThisStep = false;
+        return "text";
+      }
+      case "reasoning-start":
+      case "reasoning-delta":
+      case "reasoning-end":
+      case "reasoning": {
+        this.sawExplicitReasoningThisStep = true;
+        return "text";
+      }
+      case "text-start": {
+        const phase = getOpenAITextPhase2(chunk);
+        if (textPartId && phase)
+          this.phaseByTextPartId.set(textPartId, phase);
+        return "skip";
+      }
+      case "text-end": {
+        if (textPartId)
+          this.phaseByTextPartId.delete(textPartId);
+        return "skip";
+      }
+      case "text-delta": {
+        if (!textPartId)
+          return "text";
+        if (this.phaseByTextPartId.get(textPartId) !== "commentary") {
+          return "text";
+        }
+        return this.sawExplicitReasoningThisStep ? "skip" : "reasoning";
+      }
+      default:
+        return "text";
+    }
   }
-  return output;
 }
-function buildTurnProviderOptions(input) {
-  const {
-    modelString,
-    thinkingEffort,
-    promptCachingEnabled,
-    openaiPromptCacheRetention,
-    googleCachedContent,
-    toolCount,
-    hasSystemPrompt
-  } = input;
-  const thinkingOpts = thinkingEffort ? getThinkingProviderOptions(modelString, thinkingEffort) : null;
-  const reasoningSummaryRequested = isRecord6(thinkingOpts) && isRecord6(thinkingOpts.openai) && typeof thinkingOpts.openai.reasoningSummary === "string";
-  const cacheFamily = getCacheFamily(modelString);
-  const cacheOpts = getCachingProviderOptions(modelString, {
-    enabled: promptCachingEnabled,
-    openaiRetention: openaiPromptCacheRetention,
-    googleCachedContent,
-    googleExplicitCachingCompatible: toolCount === 0 && !hasSystemPrompt
-  });
-  const baseProviderOpts = {
-    ...thinkingOpts ?? {},
-    ...isOpenAIGPT(modelString) ? {
-      openai: {
-        store: false,
-        ...isRecord6(thinkingOpts?.openai) ? thinkingOpts.openai : {}
-      }
-    } : {}
-  };
-  const providerOptions = cacheOpts ? mergeDeep(baseProviderOpts, cacheOpts) : baseProviderOpts;
+function mapCommentaryChunkToTurnEvent(chunk) {
+  if (chunk.type !== "text-delta")
+    return null;
   return {
-    cacheFamily,
-    thinkingOpts,
-    cacheOpts,
-    providerOptions,
-    reasoningSummaryRequested
+    type: "reasoning-delta",
+    delta: extractTextDelta(chunk)
   };
 }
 
-// src/llm-api/turn-request.ts
-function buildTurnPreparation(input) {
-  const providerOptionsResult = buildTurnProviderOptions({
-    modelString: input.modelString,
-    thinkingEffort: input.thinkingEffort,
-    promptCachingEnabled: input.promptCachingEnabled,
-    openaiPromptCacheRetention: input.openaiPromptCacheRetention,
-    googleCachedContent: input.googleCachedContent,
-    toolCount: input.toolCount,
-    hasSystemPrompt: Boolean(input.systemPrompt)
-  });
-  const prepared = prepareTurnMessages({
-    messages: input.messages,
-    modelString: input.modelString,
-    toolCount: input.toolCount,
-    systemPrompt: input.systemPrompt,
-    pruningMode: input.pruningMode,
-    toolResultPayloadCapBytes: input.toolResultPayloadCapBytes,
-    promptCachingEnabled: input.promptCachingEnabled
-  });
-  return { providerOptionsResult, prepared };
-}
-function buildStreamTextRequest(input) {
-  return {
-    model: input.model,
-    messages: input.prepared.messages,
-    tools: input.toolSet,
-    stopWhen: stepCountIs(input.maxSteps),
-    onStepFinish: input.onStepFinish,
-    prepareStep: ({ stepNumber }) => {
-      if (stepNumber >= input.maxSteps - 1) {
-        return { activeTools: [] };
+class StreamToolCallTracker {
+  syntheticCount = 0;
+  pendingByTool = new Map;
+  deferredStartsByTool = new Map;
+  prepare(chunk) {
+    const type = chunk.type;
+    if (!type) {
+      return { chunk, suppressTurnEvent: false };
+    }
+    if (type === "tool-input-start") {
+      const toolName = normalizeToolName(chunk.toolName);
+      const toolCallId = normalizeToolCallId(chunk.toolCallId);
+      const args = extractToolArgs(chunk);
+      if (!hasRenderableToolArgs(args)) {
+        if (!toolCallId) {
+          this.trackDeferredStart(toolName);
+          return { chunk, suppressTurnEvent: true };
+        }
+        return { chunk, suppressTurnEvent: false };
+      }
+      return {
+        chunk: this.trackRenderableStart(chunk, toolName, toolCallId),
+        suppressTurnEvent: false
+      };
+    }
+    if (type === "tool-call") {
+      const toolName = normalizeToolName(chunk.toolName);
+      this.consumeDeferredStart(toolName);
+      return {
+        chunk: this.trackRenderableStart(chunk, toolName, normalizeToolCallId(chunk.toolCallId)),
+        suppressTurnEvent: false
+      };
+    }
+    if (TOOL_RESULT_CHUNK_TYPES.has(type)) {
+      const toolName = normalizeToolName(chunk.toolName);
+      const existingToolCallId = normalizeToolCallId(chunk.toolCallId);
+      if (existingToolCallId) {
+        this.consumeTracked(toolName, existingToolCallId);
+        return { chunk, suppressTurnEvent: false };
       }
+      const nextToolCallId = this.consumeNextTracked(toolName) ?? this.nextSyntheticToolCallId();
+      return {
+        chunk: { ...chunk, toolCallId: nextToolCallId },
+        suppressTurnEvent: false
+      };
+    }
+    return { chunk, suppressTurnEvent: false };
+  }
+  trackRenderableStart(chunk, toolName, existingToolCallId) {
+    const toolCallId = existingToolCallId ?? this.nextSyntheticToolCallId();
+    this.trackStart(toolName, toolCallId);
+    if (toolCallId === chunk.toolCallId)
+      return chunk;
+    return { ...chunk, toolCallId };
+  }
+  nextSyntheticToolCallId() {
+    this.syntheticCount += 1;
+    return `synthetic-tool-call-${this.syntheticCount}`;
+  }
+  trackStart(toolName, toolCallId) {
+    const pending = this.pendingByTool.get(toolName) ?? [];
+    pending.push(toolCallId);
+    this.pendingByTool.set(toolName, pending);
+  }
+  trackDeferredStart(toolName) {
+    this.deferredStartsByTool.set(toolName, (this.deferredStartsByTool.get(toolName) ?? 0) + 1);
+  }
+  consumeDeferredStart(toolName) {
+    const count = this.deferredStartsByTool.get(toolName) ?? 0;
+    if (count <= 0)
       return;
-    },
-    ...input.prepared.systemPrompt ? { system: input.prepared.systemPrompt } : {},
-    ...Object.keys(input.providerOptions).length > 0 ? {
-      providerOptions: input.providerOptions
-    } : {},
-    ...input.signal ? { abortSignal: input.signal } : {},
-    onError: () => {},
-    timeout: { chunkMs: 120000 }
-  };
+    if (count === 1) {
+      this.deferredStartsByTool.delete(toolName);
+      return;
+    }
+    this.deferredStartsByTool.set(toolName, count - 1);
+  }
+  consumeTracked(toolName, toolCallId) {
+    const pending = this.pendingByTool.get(toolName);
+    if (!pending || pending.length === 0)
+      return;
+    const idx = pending.indexOf(toolCallId);
+    if (idx === -1)
+      return;
+    pending.splice(idx, 1);
+    if (pending.length === 0)
+      this.pendingByTool.delete(toolName);
+  }
+  consumeNextTracked(toolName) {
+    const pending = this.pendingByTool.get(toolName);
+    if (!pending || pending.length === 0)
+      return null;
+    const toolCallId = pending.shift() ?? null;
+    if (pending.length === 0)
+      this.pendingByTool.delete(toolName);
+    return toolCallId;
+  }
+}
+async function* mapFullStreamToTurnEvents(stream, opts) {
+  const toolCallTracker = new StreamToolCallTracker;
+  const textPhaseTracker = new StreamTextPhaseTracker;
+  for await (const originalChunk of stream) {
+    const prepared = toolCallTracker.prepare(originalChunk);
+    const chunk = prepared.chunk;
+    const route = textPhaseTracker.route(chunk);
+    if (!prepared.suppressTurnEvent && route !== "skip" && shouldLogStreamChunk(chunk)) {
+      opts.onChunk?.(chunk);
+    }
+    if (prepared.suppressTurnEvent || route === "skip")
+      continue;
+    const event = route === "reasoning" ? mapCommentaryChunkToTurnEvent(chunk) : mapStreamChunkToTurnEvent(chunk);
+    if (event)
+      yield event;
+  }
 }
 
 // src/llm-api/turn.ts
-var MAX_STEPS = 50;
+var MAX_STEPS2 = 50;
 async function* runTurn(options) {
+  if (options.modelString.startsWith("anthropic/") && isLoggedIn("anthropic")) {
+    const token = await getAccessToken("anthropic");
+    if (token) {
+      yield* runTurnAnthropicOAuth({ ...options, token });
+      return;
+    }
+  }
   const {
     model,
     modelString,
@@ -5392,7 +6006,7 @@ async function* runTurn(options) {
       onStepFinish: stepTracker.onStepFinish,
       signal,
       providerOptions: providerOptionsResult.providerOptions,
-      maxSteps: MAX_STEPS
+      maxSteps: MAX_STEPS2
     }));
     result.response.catch(() => {});
     for await (const event of mapFullStreamToTurnEvents(result.fullStream, {