@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/{chunk-ZKZHSB5W.js → chunk-QR4Q425T.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   readRuntimeStatus
-} from "./chunk-36HCNKDS.js";
+} from "./chunk-WKVZES7O.js";
 import {
   atomicWriteJSON
 } from "./chunk-XFFRI3WM.js";
@@ -67,17 +67,17 @@ async function readWorktreeSessionStrict(filePath) {
   let observedSidecar = false;
   try {
     const flags = nodeFs.constants.O_RDONLY | (nodeFs.constants.O_NOFOLLOW ?? 0) | (nodeFs.constants.O_NONBLOCK ?? 0);
-    const before = await fs.lstat(filePath);
+    const before = await fs.lstat(filePath, { bigint: true });
     observedSidecar = true;
-    if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1) {
+    if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1n) {
       return { state: "invalid", reason: "unsafe sidecar file type" };
     }
-    if (before.ino === 0 || before.size > WORKTREE_SESSION_SIDECAR_MAX_BYTES) {
+    if (before.ino === 0n || before.size > BigInt(WORKTREE_SESSION_SIDECAR_MAX_BYTES)) {
       return { state: "invalid", reason: "unsafe sidecar size or identity" };
     }
     handle = await fs.open(filePath, flags);
-    const opened = await handle.stat();
-    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== before.dev || opened.ino !== before.ino) {
+    const opened = await handle.stat({ bigint: true });
+    if (!opened.isFile() || opened.nlink !== 1n || opened.dev !== before.dev || opened.ino !== before.ino) {
       return {
         state: "invalid",
         reason: "sidecar identity changed before read"
@@ -98,9 +98,9 @@ async function readWorktreeSessionStrict(filePath) {
     if (bytesRead > WORKTREE_SESSION_SIDECAR_MAX_BYTES) {
       return { state: "invalid", reason: "unsafe sidecar size or identity" };
     }
-    const after = await handle.stat();
-    const pathStats = await fs.lstat(filePath);
-    if (!after.isFile() || after.nlink !== 1 || after.size !== bytesRead || after.dev !== opened.dev || after.ino !== opened.ino || !pathStats.isFile() || pathStats.nlink !== 1 || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
+    const after = await handle.stat({ bigint: true });
+    const pathStats = await fs.lstat(filePath, { bigint: true });
+    if (!after.isFile() || after.nlink !== 1n || after.size !== BigInt(bytesRead) || after.dev !== opened.dev || after.ino !== opened.ino || !pathStats.isFile() || pathStats.nlink !== 1n || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
       return {
         state: "invalid",
         reason: "sidecar identity changed during read"

package/chunks/{chunk-J6MB5ZHZ.js → chunk-QZW6WRB7.js}

@@ -9074,10 +9074,11 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
               filePath,
               signal ?? new AbortController().signal
             );
+            const zoomHint = config.getCodeModeOnly?.() ? `If details are too small, call tools.zoom_image with coordinates normalized from 0 to 1000.` : `If details are too small, use tool_search for "zoom image", then call zoom_image with coordinates normalized from 0 to 1000.`;
             return {
               llmContent: [
                 {
-                  text: `Image overview: ${view.outputWidth}x${view.outputHeight}; oriented source: ${view.sourceWidth}x${view.sourceHeight}. If details are too small, use tool_search for "zoom image", then call zoom_image with coordinates normalized from 0 to 1000.`
+                  text: `Image overview: ${view.outputWidth}x${view.outputHeight}; oriented source: ${view.sourceWidth}x${view.sourceHeight}. ` + zoomHint
                 },
                 {
                   inlineData: {

package/chunks/{chunk-3BTSSIJO.js → chunk-RHTNPDGD.js}

@@ -4,22 +4,23 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-MOS5OAOG.js";
+} from "./chunk-SROLVJFY.js";
 import {
   applyOfficialOpenAIPromptCaching,
-  isOfficialOpenAIEndpoint
-} from "./chunk-SAH4BD2J.js";
+  isOfficialOpenAIEndpoint,
+  trailingReattachPartCount
+} from "./chunk-WFNEY5G7.js";
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider,
   isOpenRouterHostname
-} from "./chunk-CXTPVBFA.js";
+} from "./chunk-GSS4SZNG.js";
 import {
   getCurrentAgentId
-} from "./chunk-U7O65WKL.js";
+} from "./chunk-BW2SMO6L.js";
 import {
   isInForkExecution
-} from "./chunk-FN3JNDRU.js";
+} from "./chunk-VVI7MK3V.js";
 import {
   extractTextFromContents
 } from "./chunk-AYEJOTIU.js";
@@ -36,8 +37,9 @@ import {
 } from "./chunk-VNOVK4I7.js";
 import {
   InvalidStreamError,
-  getToolCallPreparations
-} from "./chunk-CFKIH3D3.js";
+  getToolCallPreparations,
+  markFlushedToolCallPark
+} from "./chunk-S7UQ3V2H.js";
 import {
   safeJsonParse
 } from "./chunk-GSKX53AN.js";
@@ -47,7 +49,7 @@ import {
 import {
   getRateLimitErrorDetails,
   getTransportCode
-} from "./chunk-4ALNJDHL.js";
+} from "./chunk-ZKIAGIGH.js";
 import {
   reportOpenAiChunk,
   reportOpenAiRequest,
@@ -56,17 +58,17 @@ import {
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-TRKIKBUW.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   REASONING_EFFORT_TIERS,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
   parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+} from "./chunk-ARDHE6MM.js";
 import {
   reconcileMaxTokens
 } from "./chunk-FPGTNKCP.js";
@@ -476,6 +478,49 @@ var CerebrasOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
   }
 };
 
+// packages/core/src/core/openaiContentGenerator/provider/fireworks.ts
+init_esbuild_shims();
+var FIREWORKS_API_HOST = "api.fireworks.ai";
+function isFireworksProvider(config) {
+  const baseUrl = config.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === FIREWORKS_API_HOST || hostname.endsWith(`.${FIREWORKS_API_HOST}`);
+  } catch {
+    return false;
+  }
+}
+__name(isFireworksProvider, "isFireworksProvider");
+var FireworksOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
+  static {
+    __name(this, "FireworksOpenAICompatibleProvider");
+  }
+  static isFireworksProvider = isFireworksProvider;
+  buildRequest(request, userPromptId) {
+    const baseRequest = super.buildRequest(request, userPromptId);
+    return {
+      ...baseRequest,
+      messages: baseRequest.messages.map(unmirrorReasoningField)
+    };
+  }
+};
+function unmirrorReasoningField(message) {
+  if (message.role !== "assistant") {
+    return message;
+  }
+  const assistant = message;
+  if (assistant.reasoning !== assistant.reasoning_content) {
+    return message;
+  }
+  if (typeof assistant.reasoning !== "string") {
+    return message;
+  }
+  const { reasoning: _drop, ...rest } = assistant;
+  return rest;
+}
+__name(unmirrorReasoningField, "unmirrorReasoningField");
+
 // packages/core/src/core/openaiContentGenerator/provider/mimo.ts
 init_esbuild_shims();
 function isMiMoProvider(contentGeneratorConfig) {
@@ -1118,6 +1163,14 @@ function isSSECompatibleContentType(contentType) {
   return mediaType === "text/event-stream" || mediaType === "application/x-ndjson" || mediaType === "application/stream+json";
 }
 __name(isSSECompatibleContentType, "isSSECompatibleContentType");
+function hasNonThoughtCandidateParts(response) {
+  return Boolean(
+    response.candidates?.some(
+      (candidate) => candidate.content?.parts?.some((part) => !part.thought)
+    )
+  );
+}
+__name(hasNonThoughtCandidateParts, "hasNonThoughtCandidateParts");
 var NonSSEResponseError = class extends Error {
   constructor(contentType, httpStatus, bodyPrefix, requestId) {
     const preview = bodyPrefix.length > 0 ? ` Body prefix: ${bodyPrefix}` : "";
@@ -1293,6 +1346,7 @@ var ContentGenerationPipeline = class {
   async *processStreamWithLogging(stream, context, request, userPromptId, telemetryAttempt) {
     let pendingFinishResponse = null;
     let finishYielded = false;
+    let contentYielded = request.continuationInFlight === true;
     let pendingFinishProtocolTagSanitized;
     const logPendingProtocolTagSanitized = /* @__PURE__ */ __name((response, sanitization) => {
       if (!sanitization) return;
@@ -1364,9 +1418,10 @@ var ContentGenerationPipeline = class {
               pendingFinishResponse,
               pendingFinishProtocolTagSanitized
             );
-            yield pendingFinishResponse;
             finishYielded = true;
+            yield pendingFinishResponse;
           } else {
+            contentYielded ||= hasNonThoughtCandidateParts(response);
             logPendingProtocolTagSanitized(response, sanitization);
             yield response;
           }
@@ -1384,6 +1439,7 @@ var ContentGenerationPipeline = class {
               index: 0
             }
           ];
+          contentYielded ||= hasNonThoughtCandidateParts(response);
           yield response;
         }
       } else if (context.pendingThinkingTagCandidate || context.responseParsingOptions?.taggedThinkingTagsAfterReasoning && context.taggedThinkingParser?.hasUnclosedThought()) {
@@ -1397,12 +1453,33 @@ var ContentGenerationPipeline = class {
           pendingFinishResponse,
           pendingFinishProtocolTagSanitized
         );
+        finishYielded = true;
         yield pendingFinishResponse;
       }
     } catch (error) {
       if (error instanceof InvalidStreamError) {
         throw error;
       }
+      const parked = pendingFinishResponse;
+      const parkedHasToolCall = parked?.candidates?.some(
+        (candidate) => candidate.content?.parts?.some((part) => part.functionCall)
+      );
+      if (pendingFinishResponse && !finishYielded && // A cancellation is not a stream failure to recover from: synthesising
+      // a delivery here hands the consumer a finish it was never shown, and
+      // cancellation persistence keeps whatever the consumer received.
+      // Spelled exactly as the PROTOCOL_TAG_LEAK branch below spells it, so
+      // one catch does not hold two notions of "aborted".
+      request.config?.abortSignal?.aborted !== true && (!parkedHasToolCall || contentYielded)) {
+        logPendingProtocolTagSanitized(
+          pendingFinishResponse,
+          pendingFinishProtocolTagSanitized
+        );
+        if (parkedHasToolCall) {
+          markFlushedToolCallPark(pendingFinishResponse);
+        }
+        yield pendingFinishResponse;
+        finishYielded = true;
+      }
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
@@ -1528,7 +1605,8 @@ var ContentGenerationPipeline = class {
     }
     let providerRequest = this.config.provider.buildRequest(
       baseRequest,
-      userPromptId
+      userPromptId,
+      trailingReattachPartCount(request.contents)
     );
     if (this.contentGeneratorConfig.enableCacheControl !== false && isOfficialOpenAIEndpoint(this.contentGeneratorConfig)) {
       providerRequest = applyOfficialOpenAIPromptCaching(
@@ -2018,6 +2096,12 @@ function determineProvider(contentGeneratorConfig, cliConfig) {
       cliConfig
     );
   }
+  if (FireworksOpenAICompatibleProvider.isFireworksProvider(config)) {
+    return new FireworksOpenAICompatibleProvider(
+      contentGeneratorConfig,
+      cliConfig
+    );
+  }
   return new DefaultOpenAICompatibleProvider(contentGeneratorConfig, cliConfig);
 }
 __name(determineProvider, "determineProvider");
@@ -2027,6 +2111,7 @@ export {
   MiniMaxOpenAICompatibleProvider,
   MistralOpenAICompatibleProvider,
   CerebrasOpenAICompatibleProvider,
+  FireworksOpenAICompatibleProvider,
   MiMoOpenAICompatibleProvider,
   ContentGenerationPipeline,
   EnhancedErrorHandler,

package/chunks/{chunk-OLTN767L.js → chunk-RJFUPP3F.js}

@@ -3,11 +3,11 @@
 import {
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   detectTurnInterruption
-} from "./chunk-BZM5U74J.js";
+} from "./chunk-I6JRN375.js";
 import {
   SessionService,
   buildApiHistoryFromConversation
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-RKXAOP6F.js

@@ -0,0 +1,154 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getNestedProperty,
+  getPersistScopeForModelSelection
+} from "./chunk-PVKEYO5D.js";
+import {
+  getHomeEnvFallbackVars
+} from "./chunk-IGLX6UXJ.js";
+import {
+  writeWithBackupSync
+} from "./chunk-2P2IXKDR.js";
+import {
+  resolveEnvVarsInObject
+} from "./chunk-65I7S4Z3.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/loadedSettingsAdapter.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+function preservePlaceholders(value, resolved, original) {
+  if (typeof original === "string" && value === resolved) return original;
+  if (Array.isArray(value) && Array.isArray(resolved) && Array.isArray(original)) {
+    return value.map(
+      (entry, index) => preservePlaceholders(entry, resolved[index], original[index])
+    );
+  }
+  if (value && resolved && original && typeof value === "object" && !Array.isArray(value) && typeof resolved === "object" && !Array.isArray(resolved) && typeof original === "object" && !Array.isArray(original)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        preservePlaceholders(
+          entry,
+          resolved[key],
+          original[key]
+        )
+      ])
+    );
+  }
+  return value;
+}
+__name(preservePlaceholders, "preservePlaceholders");
+function createLoadedSettingsAdapter(settings, scope) {
+  const persistScope = scope ?? getPersistScopeForModelSelection(settings);
+  const settingsFile = settings.forScope(persistScope);
+  let fileSnapshot;
+  let settingsSnapshot = null;
+  let originalSnapshot = null;
+  return {
+    getValue(key) {
+      return getNestedProperty(settings.merged, key);
+    },
+    setValue(key, value) {
+      for (const part of key.split(".")) {
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          throw new Error(
+            `Refusing to write settings key with reserved segment: ${key}`
+          );
+        }
+      }
+      const provider = key.startsWith("modelProviders.") && key.split(".").length === 2 ? key.slice("modelProviders.".length) : void 0;
+      if (!provider || !Array.isArray(value)) {
+        settings.setValue(persistScope, key, value);
+        return;
+      }
+      const previous = settings.merged.modelProviders?.[provider];
+      const source = [
+        "System" /* System */,
+        ...settings.isTrusted ? ["Workspace" /* Workspace */] : [],
+        "User" /* User */,
+        "SystemDefaults" /* SystemDefaults */
+      ].map(
+        (source2) => settings.forScope(source2).originalSettings.modelProviders
+      ).find((providers) => providers && Object.hasOwn(providers, provider));
+      const raw = source?.[provider];
+      const models = value;
+      const persisted = !Array.isArray(previous) || !Array.isArray(raw) ? models : models.map((model) => {
+        if (!model) return model;
+        const matches = previous.flatMap(
+          (entry, index2) => entry?.id === model.id && entry.baseUrl === model.baseUrl ? [index2] : []
+        );
+        if (matches.length > 1 && JSON.stringify(previous) !== JSON.stringify(raw)) {
+          throw new Error(
+            "Cannot preserve placeholders in an ambiguous model configuration. Remove duplicate model entries first."
+          );
+        }
+        const index = matches[0];
+        return index === void 0 ? model : preservePlaceholders(model, previous[index], raw[index]);
+      });
+      settings.setValue(persistScope, key, persisted);
+      settingsFile.settings.modelProviders = {
+        ...settingsFile.settings.modelProviders,
+        [provider]: resolveEnvVarsInObject(persisted, getHomeEnvFallbackVars())
+      };
+      settings.recomputeMerged();
+    },
+    getModelProviders() {
+      return settings.merged.modelProviders ?? {};
+    },
+    persist() {
+    },
+    backup() {
+      const contents = fs.existsSync(settingsFile.path) ? fs.readFileSync(settingsFile.path, "utf8") : null;
+      settingsSnapshot = structuredClone(settingsFile.settings);
+      originalSnapshot = structuredClone(settingsFile.originalSettings);
+      fileSnapshot = contents;
+    },
+    restore() {
+      if (fileSnapshot === void 0) return;
+      try {
+        if (fileSnapshot === null) {
+          fs.rmSync(settingsFile.path, { force: true });
+        } else {
+          writeWithBackupSync(settingsFile.path, fileSnapshot);
+        }
+      } finally {
+        if (settingsSnapshot !== null) {
+          settingsFile.settings = settingsSnapshot;
+        }
+        if (originalSnapshot !== null) {
+          settingsFile.originalSettings = originalSnapshot;
+        }
+        settings.recomputeMerged();
+      }
+    },
+    cleanupBackup() {
+      fileSnapshot = void 0;
+      settingsSnapshot = null;
+      originalSnapshot = null;
+    }
+  };
+}
+__name(createLoadedSettingsAdapter, "createLoadedSettingsAdapter");
+
+export {
+  createLoadedSettingsAdapter
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapter that lets core's `applyProviderInstallPlan` write through
+ * `LoadedSettings` while preserving CLI-specific guarantees:
+ * - scope resolution via `getPersistScopeForModelSelection`
+ * - original file contents for transaction rollback
+ * - in-memory snapshot of `settings` / `originalSettings` for rollback
+ * - merged-settings recomputation after restore
+ */

package/chunks/{chunk-TP6FYVQT.js → chunk-RSWBT7AZ.js}

@@ -15926,6 +15926,7 @@ var CONCURRENCY_SAFE_KINDS = /* @__PURE__ */ new Set([
 // packages/core/src/tools/tool-names.ts
 init_esbuild_shims();
 var ToolNames = {
+  EXEC: "exec",
   EDIT: "edit",
   WRITE_FILE: "write_file",
   READ_FILE: "read_file",
@@ -15978,6 +15979,7 @@ var ToolNames = {
   DISPLAY_IMAGE: "display_image"
 };
 var ToolDisplayNames = {
+  EXEC: "Exec",
   EDIT: "Edit",
   WRITE_FILE: "WriteFile",
   READ_FILE: "ReadFile",
@@ -16053,6 +16055,35 @@ var ToolDisplayNamesMigration = {
   TodoWrite: ToolDisplayNames.TODO_WRITE
   // Old display name for TodoList (renamed from TodoWrite)
 };
+var BUILTIN_TOOL_NAMES = (() => {
+  const lookup = /* @__PURE__ */ new Map();
+  const displayNames = ToolDisplayNames;
+  for (const name of Object.values(ToolNames)) {
+    lookup.set(name, name);
+  }
+  for (const [key, name] of Object.entries(ToolNames)) {
+    const display = displayNames[key];
+    if (display !== void 0 && !lookup.has(display)) {
+      lookup.set(display, name);
+    }
+  }
+  for (const [legacy, name] of Object.entries(ToolNamesMigration)) {
+    if (!lookup.has(legacy)) lookup.set(legacy, name);
+  }
+  for (const [legacyDisplay, display] of Object.entries(
+    ToolDisplayNamesMigration
+  )) {
+    const name = lookup.get(display);
+    if (name !== void 0 && !lookup.has(legacyDisplay)) {
+      lookup.set(legacyDisplay, name);
+    }
+  }
+  return lookup;
+})();
+function resolveBuiltinToolName(name) {
+  return BUILTIN_TOOL_NAMES.get(name);
+}
+__name(resolveBuiltinToolName, "resolveBuiltinToolName");
 
 export {
   require_fast_deep_equal,
@@ -16074,7 +16105,8 @@ export {
   ToolDisplayNames,
   ToolNamesMigration,
   canonicalToolName,
-  ToolDisplayNamesMigration
+  ToolDisplayNamesMigration,
+  resolveBuiltinToolName
 };
 /**
  * @license

package/chunks/{chunk-E7LB57MB.js → chunk-RWKR4VNK.js}

@@ -16,24 +16,24 @@ import {
   MODIFIER_SHIFT_BIT,
   MODIFIER_SUPER_BIT,
   clipboardHasImage
-} from "./chunk-S6Q6Q4P2.js";
+} from "./chunk-FBDHP23D.js";
+import {
+  noteInteraction
+} from "./chunk-KW7NOTN6.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
 import {
   use_stdin_default,
   use_stdout_default
-} from "./chunk-O4KNCAX4.js";
+} from "./chunk-NCPFOLM2.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
-import {
-  noteInteraction
-} from "./chunk-KW7NOTN6.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-TRKIKBUW.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

package/chunks/chunk-S7UQ3V2H.js

@@ -0,0 +1,87 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/tool-call-preparation.ts
+init_esbuild_shims();
+var preparationsByResponse = /* @__PURE__ */ new WeakMap();
+function setToolCallPreparations(response, preparations) {
+  preparationsByResponse.set(response, preparations);
+}
+__name(setToolCallPreparations, "setToolCallPreparations");
+function getToolCallPreparations(response) {
+  return preparationsByResponse.get(response) ?? [];
+}
+__name(getToolCallPreparations, "getToolCallPreparations");
+
+// packages/core/src/core/invalid-stream-error.ts
+init_esbuild_shims();
+var InvalidStreamError = class extends Error {
+  static {
+    __name(this, "InvalidStreamError");
+  }
+  type;
+  constructor(message, type) {
+    super(message);
+    this.name = "InvalidStreamError";
+    this.type = type;
+  }
+};
+
+// packages/core/src/core/stream-transport-retry.ts
+init_esbuild_shims();
+var RETRYABLE_STREAM_TRANSPORT_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+function isRetryableStreamTransportError(classification) {
+  return classification.kind === "transport" && classification.transportCode !== void 0 && RETRYABLE_STREAM_TRANSPORT_CODES.has(classification.transportCode);
+}
+__name(isRetryableStreamTransportError, "isRetryableStreamTransportError");
+function isRetryableStatuslessUpstreamError(classification) {
+  return classification.reason === "upstream-error-without-status";
+}
+__name(isRetryableStatuslessUpstreamError, "isRetryableStatuslessUpstreamError");
+var flushedToolCallParks = /* @__PURE__ */ new WeakMap();
+function markFlushedToolCallPark(response) {
+  flushedToolCallParks.set(response, true);
+}
+__name(markFlushedToolCallPark, "markFlushedToolCallPark");
+function isFlushedToolCallPark(response) {
+  return flushedToolCallParks.get(response) === true;
+}
+__name(isFlushedToolCallPark, "isFlushedToolCallPark");
+
+export {
+  setToolCallPreparations,
+  getToolCallPreparations,
+  InvalidStreamError,
+  isRetryableStreamTransportError,
+  isRetryableStatuslessUpstreamError,
+  markFlushedToolCallPark,
+  isFlushedToolCallPark
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-N6VQ37ZZ.js → chunk-SFL6U7U7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-3CZ2BQV6.js";
+} from "./chunk-NXUZFW3G.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-SODMFNAR.js → chunk-SQCZDHBQ.js}

@@ -5,26 +5,26 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   loadSettings
-} from "./chunk-7BXXIQG4.js";
+} from "./chunk-PVKEYO5D.js";
 import {
   getCurrentLanguage,
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-53GWJOLP.js";
+} from "./chunk-2P2IXKDR.js";
 import {
   ExtensionManager,
   getExtensionDescription,
   getExtensionDisplayName,
   require_prompts
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   redactUrlCredentials
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   writeStdoutLine
 } from "./chunk-7FA2II6K.js";