@qwen-code/qwen-code 0.21.2 → 0.21.3

package/chunks/{anthropicContentGenerator-OFHSZJBF.js → anthropicContentGenerator-WCBYB6JG.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-DGEIYUC3.js";
 import {
   RequestTokenizer
-} from "./chunk-FJ5WUMUQ.js";
+} from "./chunk-H36SETQS.js";
 import "./chunk-MPHPFVKK.js";
 import {
   resolveRequestTimeout
@@ -27,7 +27,7 @@ import {
   convertSchema,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-QTHQ6Z5X.js";
+} from "./chunk-WK4TJUEA.js";
 import {
   runtimeDiagnostics,
   setToolCallPreparations
@@ -37,8 +37,8 @@ import {
   reportAnthropicFollowingRequest,
   reportAnthropicRequest,
   reportAnthropicResponse
-} from "./chunk-XP4L6KS3.js";
-import "./chunk-QDK4F2N5.js";
+} from "./chunk-URN76TKR.js";
+import "./chunk-2DNKEBXY.js";
 import "./chunk-5WV5S2GT.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -54,10 +54,10 @@ import {
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-Q3T5KA2V.js";
+} from "./chunk-BFHXDAR7.js";
 import {
   createDebugLogger
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   require_ms
 } from "./chunk-YQ3U5MUC.js";
@@ -4250,11 +4250,21 @@ var AnthropicContentConverter = class {
   }
   schemaCompliance;
   enableCacheControl;
+  /**
+   * Per-request tool ID sanitization state (see {@link resolveToolUseId}).
+   * The converter instance is long-lived across requests (constructed once
+   * per generator), so this state is reset at the top of every
+   * `convertGeminiRequestToAnthropic` call rather than at construction.
+   */
+  toolIdMap = /* @__PURE__ */ new Map();
+  usedToolIds = /* @__PURE__ */ new Set();
+  generatedToolIdCounter = 0;
   constructor(_model, schemaCompliance = "auto", enableCacheControl = true) {
     this.schemaCompliance = schemaCompliance;
     this.enableCacheControl = enableCacheControl;
   }
   convertGeminiRequestToAnthropic(request, options = {}) {
+    this.resetToolIdState();
     let messages = [];
     const systemText = this.extractTextFromContentUnion(
       request.config?.systemInstruction
@@ -4275,19 +4285,39 @@ var AnthropicContentConverter = class {
     if (options.dropUnsignedAssistantThinking) {
       messages = this.dropUnsignedThinkingFromAssistantMessages(messages);
     }
+    if (!options.injectThinkingOnToolUseTurns) {
+      messages = dropEmptyTextThinkingBlocks(messages);
+    }
     if (options.stripAssistantThinking) {
       this.stripThinkingFromAssistantMessages(messages);
     }
     messages = mergeConsecutiveUserMessages(messages);
+    if (options.stripTrailingAssistantPrefill) {
+      this.stripTrailingAssistantPrefill(messages);
+    }
     const enableCacheControl = options.enableCacheControl ?? this.enableCacheControl;
     const useGlobalCacheScope = options.useGlobalCacheScope ?? false;
+    const cacheRetention = options.cacheRetention ?? "ephemeral";
+    const cacheRetentionByBlock = options.cacheRetentionByBlock ?? {};
     const system = enableCacheControl ? this.buildSystemWithCacheControl(
       systemText,
       useGlobalCacheScope,
-      options.staticSystemPrefix
+      options.staticSystemPrefix,
+      this.resolveCacheRetention(
+        "system",
+        cacheRetention,
+        cacheRetentionByBlock
+      )
     ) : systemText;
     if (enableCacheControl) {
-      this.addCacheControlToMessages(messages);
+      this.addCacheControlToMessages(
+        messages,
+        this.resolveCacheRetention(
+          "user.last",
+          cacheRetention,
+          cacheRetentionByBlock
+        )
+      );
     }
     return {
       system,
@@ -4334,9 +4364,18 @@ var AnthropicContentConverter = class {
     const useGlobalCacheScope = options.useGlobalCacheScope ?? false;
     if (enableCacheControl && tools.length > 0) {
       const lastToolIndex = tools.length - 1;
+      const resolvedRetention = this.resolveCacheRetention(
+        "tool",
+        options.cacheRetention ?? "ephemeral",
+        options.cacheRetentionByBlock ?? {}
+      );
       tools[lastToolIndex] = {
         ...tools[lastToolIndex],
-        cache_control: useGlobalCacheScope ? { type: "ephemeral", scope: "global" } : { type: "ephemeral" }
+        cache_control: {
+          type: "ephemeral",
+          ...useGlobalCacheScope ? { scope: "global" } : {},
+          ...resolvedRetention === "1h" ? { ttl: "1h" } : {}
+        }
       };
     }
     return tools;
@@ -4427,7 +4466,6 @@ var AnthropicContentConverter = class {
     const parts = content.parts || [];
     const role = content.role === "model" ? "assistant" : "user";
     const contentBlocks = [];
-    let toolCallIndex = 0;
     for (const part of parts) {
       if (typeof part === "string") {
         contentBlocks.push({ type: "text", text: part });
@@ -4456,11 +4494,10 @@ var AnthropicContentConverter = class {
         if (role === "assistant") {
           contentBlocks.push({
             type: "tool_use",
-            id: part.functionCall.id || `tool_${toolCallIndex}`,
+            id: this.resolveToolUseId(part.functionCall.id),
             name: normalizeMcpToolName(part.functionCall.name || ""),
             input: part.functionCall.args || {}
           });
-          toolCallIndex += 1;
         }
       }
       if (part.functionResponse) {
@@ -4473,6 +4510,13 @@ var AnthropicContentConverter = class {
       }
     }
     if (contentBlocks.length > 0) {
+      if (role === "user" && contentBlocks.some((b) => b.type === "tool_result")) {
+        contentBlocks.sort((a, b) => {
+          if (a.type === "tool_result" && b.type !== "tool_result") return -1;
+          if (a.type !== "tool_result" && b.type === "tool_result") return 1;
+          return 0;
+        });
+      }
       messages.push({ role, content: contentBlocks });
     }
   }
@@ -4498,11 +4542,68 @@ var AnthropicContentConverter = class {
     }
     return {
       type: "tool_result",
-      tool_use_id: response.id || "",
+      tool_use_id: this.resolveToolUseId(response.id),
       content,
       ...response.response && Object.prototype.hasOwnProperty.call(response.response, "error") ? { is_error: true } : {}
     };
   }
+  resetToolIdState() {
+    this.toolIdMap.clear();
+    this.usedToolIds.clear();
+    this.generatedToolIdCounter = 0;
+  }
+  /**
+   * Resolve a `functionCall.id` / `functionResponse.id` into a wire-safe
+   * `tool_use.id` / `tool_result.tool_use_id`. Anthropic validates both
+   * fields against `^[a-zA-Z0-9_-]+$` server-side (HTTP 400 otherwise) and
+   * rejects the empty string the same way, since `+` requires at least one
+   * character. The Gemini lingua-franca's `id` field has no such
+   * constraint -- it can carry another provider's ID scheme, a
+   * composite/namespaced ID, or be entirely absent.
+   *
+   * The same source ID always resolves to the same wire ID within a
+   * request (memoized in `toolIdMap`), so a `tool_use`/`tool_result` pair
+   * that shares a source ID still links up correctly after sanitization.
+   * State is scoped to a single `convertGeminiRequestToAnthropic` call
+   * (reset via {@link resetToolIdState}), since the converter instance
+   * itself is long-lived across requests.
+   */
+  resolveToolUseId(rawId) {
+    const sourceId = typeof rawId === "string" ? rawId.trim() : "";
+    const existingId = sourceId ? this.toolIdMap.get(sourceId) : void 0;
+    if (existingId) {
+      return existingId;
+    }
+    const baseId = sourceId ? this.sanitizeToolUseId(sourceId) : this.nextGeneratedToolId();
+    const uniqueId = this.makeUniqueToolUseId(baseId);
+    if (sourceId) {
+      this.toolIdMap.set(sourceId, uniqueId);
+    }
+    return uniqueId;
+  }
+  sanitizeToolUseId(id) {
+    const cleaned = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return cleaned || this.nextGeneratedToolId();
+  }
+  nextGeneratedToolId() {
+    const id = `tool_${this.generatedToolIdCounter}`;
+    this.generatedToolIdCounter += 1;
+    return id;
+  }
+  makeUniqueToolUseId(baseId) {
+    if (!this.usedToolIds.has(baseId)) {
+      this.usedToolIds.add(baseId);
+      return baseId;
+    }
+    let suffix = 1;
+    let candidate = `${baseId}_${suffix}`;
+    while (this.usedToolIds.has(candidate)) {
+      suffix += 1;
+      candidate = `${baseId}_${suffix}`;
+    }
+    this.usedToolIds.add(candidate);
+    return candidate;
+  }
   createMediaBlockFromPart(part) {
     if (part.inlineData?.mimeType && part.inlineData?.data) {
       if (this.isSupportedAnthropicImageMimeType(part.inlineData.mimeType)) {
@@ -4629,6 +4730,44 @@ var AnthropicContentConverter = class {
   isContentObject(content) {
     return typeof content === "object" && content !== null && "role" in content && "parts" in content && Array.isArray(content["parts"]);
   }
+  /**
+   * Resolve the effective {@link CacheRetention} for one cache anchor,
+   * normalized so retention is monotonically non-increasing in wire order.
+   *
+   * Render order is `tools` -> `system` -> `messages`, so this converter's
+   * three anchors sit on the wire in exactly that order: `tool` -> `system`
+   * -> `user.last`. Anthropic requires "cache entries with longer TTL must
+   * appear before shorter TTLs" — an anchor at the spec's 5-minute default
+   * (no `ttl`) is a short-TTL entry for this rule's purposes, so a raw
+   * per-anchor override like `cacheRetentionByBlock: { system: '1h' }`
+   * would otherwise leave the (still 5m-default) `tool` anchor ahead of a
+   * 1h `system` anchor on the wire — an ordering violation Anthropic 400s
+   * on.
+   *
+   * Resolving with a scan instead of a straight per-anchor lookup avoids
+   * that: `anchor` resolves to `'1h'` if `anchor` itself OR any anchor
+   * later on the wire resolves to `'1h'`. That makes every
+   * `cacheRetentionByBlock` configuration legal — anchors before a `'1h'`
+   * anchor are promoted to `'1h'` too — without adding a new error surface
+   * or rejecting any input. `{ tool: '1h' }` alone is unaffected (nothing
+   * follows it that needs promoting); `{ system: '1h' }` alone now also
+   * promotes `tool` to `'1h'`, which is exactly the "cache my big system
+   * prompt for an hour" usage the per-anchor override exists for.
+   */
+  resolveCacheRetention(anchor, cacheRetention, cacheRetentionByBlock) {
+    const wireOrder = [
+      "tool",
+      "system",
+      "user.last"
+    ];
+    const anchorIndex = wireOrder.indexOf(anchor);
+    for (let i = wireOrder.length - 1; i >= anchorIndex; i--) {
+      if ((cacheRetentionByBlock[wireOrder[i]] ?? cacheRetention) === "1h") {
+        return "1h";
+      }
+    }
+    return "ephemeral";
+  }
   /**
    * Build system content blocks with cache_control.
    * Anthropic prompt caching requires cache_control on system content.
@@ -4654,11 +4793,15 @@ var AnthropicContentConverter = class {
    * The split only shapes the outgoing request; stored history and
    * non-Anthropic transports keep seeing a single system string.
    */
-  buildSystemWithCacheControl(systemText, useGlobalCacheScope, staticSystemPrefix) {
+  buildSystemWithCacheControl(systemText, useGlobalCacheScope, staticSystemPrefix, cacheRetention = "ephemeral") {
     if (!systemText) {
       return systemText;
     }
-    const scopedCacheControl = useGlobalCacheScope ? { type: "ephemeral", scope: "global" } : { type: "ephemeral" };
+    const scopedCacheControl = {
+      type: "ephemeral",
+      ...useGlobalCacheScope ? { scope: "global" } : {},
+      ...cacheRetention === "1h" ? { ttl: "1h" } : {}
+    };
     if (staticSystemPrefix && systemText.length > staticSystemPrefix.length && systemText.startsWith(staticSystemPrefix)) {
       return [
         {
@@ -4669,7 +4812,16 @@ var AnthropicContentConverter = class {
         {
           type: "text",
           text: systemText.slice(staticSystemPrefix.length),
-          cache_control: { type: "ephemeral" }
+          // Deliberately never carries `scope: 'global'` (see class doc
+          // above — the suffix varies per session, cross-session reuse
+          // has ~zero hit rate). `cacheRetention` still applies: the
+          // suffix is cached within a session, and a caller that asked
+          // for the 1h tier benefits from it surviving longer gaps
+          // between turns even on this volatile block.
+          cache_control: {
+            type: "ephemeral",
+            ...cacheRetention === "1h" ? { ttl: "1h" } : {}
+          }
         }
       ];
     }
@@ -4831,6 +4983,43 @@ var AnthropicContentConverter = class {
       message.content = [emptyThinking, ...blocks];
     }
   }
+  /**
+   * Strip a trailing empty-content assistant message, or append a
+   * synthetic user turn to satisfy Anthropic's "must end with a user
+   * message" requirement (Opus/Sonnet 4.6+, every 5.x family) when the
+   * conversation would otherwise end on a non-empty assistant message.
+   * See {@link ConvertGeminiRequestToAnthropicOptions.stripTrailingAssistantPrefill}.
+   */
+  stripTrailingAssistantPrefill(messages) {
+    while (messages.length > 0) {
+      const last = messages[messages.length - 1];
+      if (last.role !== "assistant") return;
+      if (!this.isEmptyAssistantMessage(last)) break;
+      messages.pop();
+    }
+    if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+      messages.push({
+        role: "user",
+        content: [{ type: "text", text: "Continue." }]
+      });
+    }
+  }
+  isEmptyAssistantMessage(message) {
+    const content = message.content;
+    if (!content) return true;
+    if (typeof content === "string") return content.trim().length === 0;
+    if (!Array.isArray(content) || content.length === 0) return true;
+    for (const block of content) {
+      const type = block.type;
+      if (type === "text") {
+        const text = block.text;
+        if (typeof text === "string" && text.trim().length > 0) return false;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * Add cache_control to the last user message's content.
    * This enables prompt caching for the conversation context.
@@ -4843,7 +5032,7 @@ var AnthropicContentConverter = class {
    * system prefix and tool prefixes (which DO repeat across sessions) carry
    * `scope: 'global'` instead.
    */
-  addCacheControlToMessages(messages) {
+  addCacheControlToMessages(messages, cacheRetention = "ephemeral") {
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i];
       if (msg.role === "user") {
@@ -4855,7 +5044,8 @@ var AnthropicContentConverter = class {
             const isEmptyText = type === "text" && (!("text" in lastContent) || !lastContent.text);
             if ((type === "text" || type === "tool_result") && !isEmptyText) {
               lastContent.cache_control = {
-                type: "ephemeral"
+                type: "ephemeral",
+                ...cacheRetention === "1h" ? { ttl: "1h" } : {}
               };
             }
           }
@@ -4904,6 +5094,16 @@ function mergeConsecutiveAssistantMessages(messages) {
   return merged;
 }
 __name(mergeConsecutiveAssistantMessages, "mergeConsecutiveAssistantMessages");
+function makeToolResultDeduper() {
+  const seen = /* @__PURE__ */ new Set();
+  return (id) => {
+    if (!id) return true;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  };
+}
+__name(makeToolResultDeduper, "makeToolResultDeduper");
 function cleanOrphanedToolCalls(messages) {
   const validToolUseBlocks = /* @__PURE__ */ new WeakSet();
   const validToolResultBlocks = /* @__PURE__ */ new WeakSet();
@@ -4921,6 +5121,12 @@ function cleanOrphanedToolCalls(messages) {
       }
     }
     if (toolUseBlocks.size === 0) continue;
+    if (i === messages.length - 1) {
+      for (const block of toolUseBlocks.values()) {
+        validToolUseBlocks.add(block);
+      }
+      continue;
+    }
     for (let j = i + 1; j < messages.length; j++) {
       const nextMessage = messages[j];
       if (!nextMessage || nextMessage.role !== "user" || !Array.isArray(nextMessage.content)) {
@@ -4958,20 +5164,33 @@ function cleanOrphanedToolCalls(messages) {
       cleaned.push(message);
       continue;
     }
+    let toolUseRemoved = false;
+    const keepToolResult = makeToolResultDeduper();
     const filtered = blocks.filter((b) => {
       const t = b.type;
       if (t === "tool_use") {
         const id = b.id;
-        return !id || validToolUseBlocks.has(b);
+        const keep = !id || validToolUseBlocks.has(b);
+        if (!keep) toolUseRemoved = true;
+        return keep;
       }
       if (t === "tool_result") {
         const id = b.tool_use_id;
-        return !id || validToolResultBlocks.has(b);
+        if (!id) return true;
+        if (!validToolResultBlocks.has(b)) return false;
+        return keepToolResult(id);
       }
       return true;
     });
-    if (filtered.length > 0) {
-      cleaned.push({ ...message, content: filtered });
+    const survivingToolUse = filtered.some(
+      (b) => b.type === "tool_use"
+    );
+    const finalBlocks = toolUseRemoved && !survivingToolUse && message.role === "assistant" ? filtered.filter((b) => {
+      const t = b.type;
+      return t !== "thinking" && t !== "redacted_thinking";
+    }) : filtered;
+    if (finalBlocks.length > 0) {
+      cleaned.push({ ...message, content: finalBlocks });
     } else {
       debugLogger.debug(
         "cleanOrphanedToolCalls: dropping message with only orphaned tool blocks"
@@ -4981,6 +5200,38 @@ function cleanOrphanedToolCalls(messages) {
   return cleaned;
 }
 __name(cleanOrphanedToolCalls, "cleanOrphanedToolCalls");
+function dropEmptyTextThinkingBlocks(messages) {
+  let latestAssistantIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      latestAssistantIdx = i;
+      break;
+    }
+  }
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+      out.push(msg);
+      continue;
+    }
+    if (i === latestAssistantIdx) {
+      out.push(msg);
+      continue;
+    }
+    const blocks = msg.content;
+    const filtered = blocks.filter((raw) => {
+      const bType = raw.type;
+      const bThinkingRaw = raw.thinking;
+      const bThinking = typeof bThinkingRaw === "string" ? bThinkingRaw : void 0;
+      return !(bType === "thinking" && (bThinking === void 0 || bThinking.length === 0));
+    });
+    if (filtered.length === 0) continue;
+    out.push({ role: msg.role, content: filtered });
+  }
+  return out;
+}
+__name(dropEmptyTextThinkingBlocks, "dropEmptyTextThinkingBlocks");
 function mergeConsecutiveUserMessages(messages) {
   const merged = [];
   for (const message of messages) {
@@ -4990,10 +5241,14 @@ function mergeConsecutiveUserMessages(messages) {
         ...lastMessage.content,
         ...message.content
       ];
+      const keepToolResult = makeToolResultDeduper();
+      const toolResults = combined.filter((b) => {
+        if (b.type !== "tool_result") return false;
+        const id = b.tool_use_id;
+        return keepToolResult(id);
+      });
       lastMessage.content = [
-        ...combined.filter(
-          (b) => b.type === "tool_result"
-        ),
+        ...toolResults,
         ...combined.filter(
           (b) => b.type !== "tool_result"
         )
@@ -5253,6 +5508,9 @@ var AnthropicContentGenerator = class {
     if (this.hasGlobalCacheScopeOnWire(anthropicRequest)) {
       betas.push("prompt-caching-scope-2026-01-05");
     }
+    if (this.hasExtendedCacheTtlOnWire(anthropicRequest)) {
+      betas.push("extended-cache-ttl-2025-04-11");
+    }
     if (betas.length === 0) return void 0;
     const unique = Array.from(new Set(betas));
     return { "anthropic-beta": unique.join(",") };
@@ -5312,6 +5570,47 @@ var AnthropicContentGenerator = class {
     }
     return false;
   }
+  /**
+   * Whether the assembled request body carries any
+   * `cache_control: { ..., ttl: '1h' }` entry. Scans the system block,
+   * tools array, and message content blocks — every place the converter
+   * attaches `cache_control` (system text, last tool, trailing user
+   * message). Used to gate the `extended-cache-ttl-2025-04-11` beta
+   * header defensively: live verification found the header has no
+   * observable effect on this proxy/Vertex backend (identical
+   * `ephemeral_1h_input_tokens` with and without it), but a hard
+   * requirement can't be ruled out for every Anthropic-compatible
+   * backend, so it is sent whenever the body actually requests the 1h
+   * tier -- same single-source-of-truth pattern as
+   * {@link hasGlobalCacheScopeOnWire}.
+   */
+  hasExtendedCacheTtlOnWire(req) {
+    const hasTtl1h = /* @__PURE__ */ __name((block) => {
+      if (!block || typeof block !== "object") return false;
+      const cc = block.cache_control;
+      if (!cc || typeof cc !== "object") return false;
+      return cc.ttl === "1h";
+    }, "hasTtl1h");
+    if (Array.isArray(req.system)) {
+      for (const block of req.system) {
+        if (hasTtl1h(block)) return true;
+      }
+    }
+    if (Array.isArray(req.tools)) {
+      for (const tool of req.tools) {
+        if (hasTtl1h(tool)) return true;
+      }
+    }
+    if (Array.isArray(req.messages)) {
+      for (const message of req.messages) {
+        if (!Array.isArray(message.content)) continue;
+        for (const block of message.content) {
+          if (hasTtl1h(block)) return true;
+        }
+      }
+    }
+    return false;
+  }
   /**
    * Read every customHeaders entry whose key (case-insensitively) is
    * `anthropic-beta` and yield the comma-separated flags from each. Multiple
@@ -5341,8 +5640,11 @@ var AnthropicContentGenerator = class {
     const deepseekThinkingOn = isDeepSeek && !!thinking;
     const stripAssistantThinking = isDeepSeek && !thinking;
     const dropUnsignedAssistantThinking = !isDeepSeek && !!thinking && this.modelSupportsAdaptiveThinking() && !isAnthropicNativeBaseUrl(this.contentGeneratorConfig);
+    const stripTrailingAssistantPrefill = this.modelSupportsAdaptiveThinking();
     const enableCacheControl = this.contentGeneratorConfig.enableCacheControl !== false;
     const useGlobalCacheScope = this.useGlobalCacheScope();
+    const cacheRetention = this.contentGeneratorConfig.cacheRetention;
+    const cacheRetentionByBlock = this.contentGeneratorConfig.cacheRetentionByBlock;
     const { system, messages } = this.converter.convertGeminiRequestToAnthropic(
       request,
       {
@@ -5353,8 +5655,11 @@ var AnthropicContentGenerator = class {
         injectThinkingOnToolUseTurns: deepseekThinkingOn,
         dropUnsignedAssistantThinking,
         stripAssistantThinking,
+        stripTrailingAssistantPrefill,
         enableCacheControl,
         useGlobalCacheScope,
+        cacheRetention,
+        cacheRetentionByBlock,
         // Read per request (not latched at construction): the client
         // re-records the prefix whenever it rebuilds the system prompt
         // (memory refresh, model change), and the converter fails open to
@@ -5365,7 +5670,12 @@ var AnthropicContentGenerator = class {
     );
     const tools = request.config?.tools ? await this.converter.convertGeminiToolsToAnthropic(
       request.config.tools,
-      { enableCacheControl, useGlobalCacheScope }
+      {
+        enableCacheControl,
+        useGlobalCacheScope,
+        cacheRetention,
+        cacheRetentionByBlock
+      }
     ) : void 0;
     const toolChoice = this.resolveToolChoice(request, tools);
     return {
@@ -5546,7 +5856,7 @@ var AnthropicContentGenerator = class {
       this.budgetDropWarned = true;
     }
     if (this.modelSupportsAdaptiveThinking()) {
-      return { type: "adaptive" };
+      return { type: "adaptive", display: "summarized" };
     }
     const budgetTokens = effectiveEffort === "low" ? 16e3 : effectiveEffort === "max" ? 128e3 : effectiveEffort === "xhigh" ? 96e3 : effectiveEffort === "high" ? 64e3 : 32e3;
     return {

package/chunks/{artifact-tool-RDN2W7ND.js → artifact-tool-TBOYEKTY.js}

@@ -8,7 +8,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MM7TH7ZM.js";
+} from "./chunk-CFDR3GNL.js";
 import {
   Storage,
   createDebugLogger,
@@ -18,7 +18,7 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims

package/chunks/{askUserQuestion-OZERWH5R.js → askUserQuestion-23Y5WZFJ.js}

@@ -6,10 +6,10 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MM7TH7ZM.js";
+} from "./chunk-CFDR3GNL.js";
 import {
   createDebugLogger
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims