@qwen-code/qwen-code 0.19.9-nightly.20260714.9dd8389eb → 0.19.10

package/chunks/{chunk-XHW5VUIQ.js → chunk-OFEVHGVU.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-S2QXYLUB.js";
+} from "./chunk-N6FXRR6P.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-C4CXFRKY.js";
+} from "./chunk-FXMC7SL2.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,11 +16,13 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-N7FCSERB.js";
+} from "./chunk-DPFBNG72.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError
-} from "./chunk-WL4L7EZH.js";
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-OCPBI7J5.js";
@@ -34,6 +36,7 @@ import {
   WorkspaceInitSymlinkError
 } from "./chunk-KSO42X3Z.js";
 import {
+  BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
@@ -45,20 +48,20 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-PMRH4YYW.js";
+} from "./chunk-CUUXANEQ.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-T2L6SGQY.js";
+} from "./chunk-6GETGQWP.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-X7EBAABW.js";
+} from "./chunk-4YWLED2A.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
 import {
   ModelsConfig
-} from "./chunk-SSFDPGFN.js";
+} from "./chunk-K7CRWKOE.js";
 import {
   createDebugLogger
 } from "./chunk-7NFB7LBQ.js";
@@ -96,14 +99,11 @@ function voiceSettingsScopeToWire(scope) {
 }
 __name(voiceSettingsScopeToWire, "voiceSettingsScopeToWire");
 function buildWorkspaceVoiceSettingsWrites(settings, update, opts = {}) {
-  const voiceSettingsScope = getVoiceSettingsScope(
-    settings,
-    opts.workspaceTrusted
-  );
+  const voiceSettingsScope = opts.scopeOverride ?? getVoiceSettingsScope(settings, opts.workspaceTrusted);
   const writes = [];
   if (update.voiceModel !== void 0) {
     writes.push({
-      scope: getPersistScopeForModelSelection(settings),
+      scope: opts.scopeOverride ?? getPersistScopeForModelSelection(settings),
       key: "voiceModel",
       value: update.voiceModel
     });
@@ -158,13 +158,13 @@ function listAvailableVoiceModels(settings) {
   );
 }
 __name(listAvailableVoiceModels, "listAvailableVoiceModels");
-function hasConfiguredBatchVoiceTranscriptionModel(settings) {
+function hasConfiguredBatchVoiceTranscriptionModel(settings, opts = {}) {
   for (const model of listAvailableVoiceModels(settings)) {
     if (model.transport !== "qwen-asr-chat") {
       continue;
     }
     try {
-      validateWorkspaceVoiceConfig(settings, model.id);
+      validateWorkspaceVoiceConfig(settings, model.id, opts);
       return true;
     } catch (err) {
       debugLogger.debug(
@@ -223,14 +223,24 @@ function validateWorkspaceVoiceModel(settings, voiceModel) {
   return { id: model.id, transport };
 }
 __name(validateWorkspaceVoiceModel, "validateWorkspaceVoiceModel");
-function validateWorkspaceVoiceConfig(settings, voiceModel) {
+function validateWorkspaceVoiceConfig(settings, voiceModel, opts = {}) {
   const descriptor = validateWorkspaceVoiceModel(settings, voiceModel);
   try {
     const config = createVoiceModelSource(settings);
     if (descriptor.transport === "qwen-asr-chat") {
-      resolveVoiceTranscriptionConfig({ config, settings, voiceModel });
+      resolveVoiceTranscriptionConfig({
+        config,
+        settings,
+        voiceModel,
+        env: opts.env
+      });
     } else {
-      resolveVoiceStreamConfig({ config, settings, voiceModel });
+      resolveVoiceStreamConfig({
+        config,
+        settings,
+        voiceModel,
+        env: opts.env
+      });
     }
   } catch (err) {
     throw new WorkspaceVoiceError(
@@ -242,7 +252,7 @@ function validateWorkspaceVoiceConfig(settings, voiceModel) {
   return descriptor;
 }
 __name(validateWorkspaceVoiceConfig, "validateWorkspaceVoiceConfig");
-function validateWorkspaceVoiceState(settings, update) {
+function validateWorkspaceVoiceState(settings, update, opts = {}) {
   if (update.enabled === void 0 && update.mode === void 0 && update.language === void 0 && update.voiceModel === void 0) {
     throw new WorkspaceVoiceError(
       400,
@@ -265,7 +275,7 @@ function validateWorkspaceVoiceState(settings, update) {
       "A valid voiceModel is required before enabling voice."
     );
   }
-  validateWorkspaceVoiceConfig(settings, nextVoiceModel);
+  validateWorkspaceVoiceConfig(settings, nextVoiceModel, opts);
 }
 __name(validateWorkspaceVoiceState, "validateWorkspaceVoiceState");
 async function transcribeWorkspaceVoiceAudio(input) {
@@ -286,6 +296,7 @@ async function transcribeWorkspaceVoiceAudio(input) {
       config: createVoiceModelSource(input.settings),
       settings: input.settings,
       voiceModel: input.voiceModel,
+      env: input.env,
       abortSignal: input.abortSignal
     }
   );
@@ -360,8 +371,11 @@ function createDaemonWorkspaceService(deps) {
     workspaceSkillsStatusProvider,
     isChannelLive,
     persistDisabledTools,
+    persistDisabledSkills,
     persistSetting,
     persistSettings,
+    voiceEnv,
+    voiceSettingsScope,
     preheatAcpChild: preheatAcpChildOnBridge,
     queryWorkspaceStatus,
     invokeWorkspaceCommand,
@@ -370,6 +384,35 @@ function createDaemonWorkspaceService(deps) {
   } = deps;
   let lastWorkspaceSkillsStatus;
   let inFlightAcpPreheat;
+  const getWorkspaceSkillsStatus = /* @__PURE__ */ __name(async () => {
+    let status;
+    try {
+      status = await queryWorkspaceStatus(
+        SERVE_STATUS_EXT_METHODS.workspaceSkills,
+        () => createIdleWorkspaceSkillsStatus(boundWorkspace)
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      status = createIdleWorkspaceSkillsStatus(boundWorkspace);
+    }
+    if (status.initialized) {
+      lastWorkspaceSkillsStatus = status;
+      return status;
+    }
+    if (lastWorkspaceSkillsStatus) return lastWorkspaceSkillsStatus;
+    if (workspaceSkillsStatusProvider) {
+      try {
+        return await workspaceSkillsStatusProvider(boundWorkspace);
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return status;
+  }, "getWorkspaceSkillsStatus");
   return {
     // -- Status queries (delegate to ACP child via queryWorkspaceStatus) --
     async getWorkspaceMcpStatus(_ctx) {
@@ -379,35 +422,7 @@ function createDaemonWorkspaceService(deps) {
       );
     },
     async getWorkspaceSkillsStatus(_ctx) {
-      let status;
-      try {
-        status = await queryWorkspaceStatus(
-          SERVE_STATUS_EXT_METHODS.workspaceSkills,
-          () => createIdleWorkspaceSkillsStatus(boundWorkspace)
-        );
-      } catch (err) {
-        writeStderrLine(
-          `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-        status = createIdleWorkspaceSkillsStatus(boundWorkspace);
-      }
-      if (status.initialized) {
-        lastWorkspaceSkillsStatus = status;
-        return status;
-      }
-      if (lastWorkspaceSkillsStatus) {
-        return lastWorkspaceSkillsStatus;
-      }
-      if (workspaceSkillsStatusProvider) {
-        try {
-          return await workspaceSkillsStatusProvider(boundWorkspace);
-        } catch (err) {
-          writeStderrLine(
-            `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-      return status;
+      return getWorkspaceSkillsStatus();
     },
     async getWorkspaceProvidersStatus(_ctx) {
       if (workspaceProvidersStatusProvider) {
@@ -566,7 +581,10 @@ function createDaemonWorkspaceService(deps) {
     async getWorkspaceVoiceStatus(_ctx) {
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(boundWorkspace)
+        loadSettings(
+          boundWorkspace,
+          voiceEnv ? { skipLoadEnvironment: true } : true
+        )
       );
     },
     // -- Mutations --
@@ -619,11 +637,15 @@ function createDaemonWorkspaceService(deps) {
           "Workspace voice settings persistence is not available"
         );
       }
-      const settings = loadSettings(boundWorkspace);
-      validateWorkspaceVoiceState(settings, request);
+      const settings = loadSettings(
+        boundWorkspace,
+        voiceEnv ? { skipLoadEnvironment: true } : true
+      );
+      validateWorkspaceVoiceState(settings, request, { env: voiceEnv });
       const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, boundWorkspace).effective.state === "trusted";
       const writes = buildWorkspaceVoiceSettingsWrites(settings, request, {
-        workspaceTrusted
+        workspaceTrusted,
+        ...voiceSettingsScope ? { scopeOverride: voiceSettingsScope } : {}
       });
       const publishWrite = /* @__PURE__ */ __name((write) => {
         publishWorkspaceEvent({
@@ -664,6 +686,9 @@ function createDaemonWorkspaceService(deps) {
             writeStderrLine(
               `qwen serve: workspace voice partial persist error (workspace=${boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
             );
+            for (const committedWrite of committed) {
+              publishWrite(committedWrite);
+            }
             throw new WorkspaceSettingsPartialPersistError(
               `Voice settings partial persist failed: committed=${committed.length}/${writes.length}`,
               committed,
@@ -678,7 +703,10 @@ function createDaemonWorkspaceService(deps) {
       }
       return buildWorkspaceVoiceStatus(
         boundWorkspace,
-        loadSettings(boundWorkspace)
+        loadSettings(
+          boundWorkspace,
+          voiceEnv ? { skipLoadEnvironment: true } : true
+        )
       );
     },
     async setWorkspaceToolEnabled(ctx, toolName, enabled) {
@@ -690,6 +718,80 @@ function createDaemonWorkspaceService(deps) {
       });
       return { toolName, enabled };
     },
+    async setWorkspaceSkillEnabled(ctx, requestedSkillName, enabled) {
+      const normalizedName = requestedSkillName.trim().toLowerCase();
+      const status = await getWorkspaceSkillsStatus();
+      const skill = status.skills.find(
+        (candidate) => candidate.name.trim().toLowerCase() === normalizedName
+      );
+      if (!skill) throw new WorkspaceSkillNotFoundError(requestedSkillName);
+      if (skill.userInvocable === false) {
+        throw new WorkspaceSkillNotToggleableError(
+          skill.name,
+          "not_user_invocable"
+        );
+      }
+      const disabled = loadSettings(boundWorkspace).merged.skills?.disabled;
+      const disabledNames = new Set(
+        (Array.isArray(disabled) ? disabled : []).filter((name) => typeof name === "string").map((name) => name.trim().toLowerCase()).filter(Boolean)
+      );
+      if (skill.level === "extension" && skill.status === "disabled" && !disabledNames.has(normalizedName)) {
+        throw new WorkspaceSkillNotToggleableError(
+          skill.name,
+          "inactive_extension"
+        );
+      }
+      const persisted = await persistDisabledSkills(
+        boundWorkspace,
+        skill.name,
+        enabled
+      );
+      const channelLive = isChannelLive?.() ?? false;
+      let activation = channelLive ? "applied" : "deferred";
+      let sessionsRefreshed = 0;
+      let sessionsFailed = 0;
+      if (persisted.changed) {
+        lastWorkspaceSkillsStatus = void 0;
+        if (channelLive) {
+          try {
+            const refreshed = await invokeWorkspaceCommand(
+              SERVE_CONTROL_EXT_METHODS.workspaceSkillsRefresh,
+              { cwd: boundWorkspace }
+            );
+            sessionsRefreshed = refreshed.sessionsRefreshed;
+            sessionsFailed = refreshed.sessionsFailed;
+            if (sessionsFailed > 0) activation = "partial";
+          } catch (err) {
+            if (err instanceof SessionNotFoundError || err instanceof BridgeChannelClosedError) {
+              activation = "deferred";
+            } else {
+              activation = "partial";
+              sessionsFailed = 1;
+              writeStderrLine(
+                `qwen serve: workspace skill refresh failed: ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        }
+        publishWorkspaceEvent({
+          type: "settings_changed",
+          data: {
+            key: "skills.disabled",
+            value: persisted.disabled.length > 0 ? persisted.disabled : void 0,
+            scope: "workspace"
+          },
+          originatorClientId: ctx.originatorClientId
+        });
+      }
+      return {
+        skillName: skill.name,
+        enabled,
+        changed: persisted.changed,
+        activation,
+        sessionsRefreshed,
+        sessionsFailed
+      };
+    },
     async initWorkspace(ctx, opts) {
       const filename = contextFilename;
       const target = path.resolve(boundWorkspace, filename);

package/chunks/{chunk-T7FSRWQ5.js → chunk-P6LART6G.js}

@@ -61936,7 +61936,7 @@ function getLanguageFromFilePath(filePath) {
     return extensionToLanguageMap[extension];
   }
   const filename = path3.basename(filePath).toLowerCase();
-  return extensionToLanguageMap[`.${filename}`];
+  return extensionToLanguageMap[filename] ?? extensionToLanguageMap[`.${filename}`];
 }
 __name(getLanguageFromFilePath, "getLanguageFromFilePath");
 
@@ -64174,6 +64174,20 @@ function parseTaggedThinkingText(text) {
 }
 __name(parseTaggedThinkingText, "parseTaggedThinkingText");
 
+// 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/openaiContentGenerator/converter.ts
 var debugLogger6 = createDebugLogger("CONVERTER");
 var SPLIT_TOOL_MEDIA_TEXT = "(attached media from previous tool call)";
@@ -64830,6 +64844,10 @@ function hasThoughtPart(parts) {
   return parts.some((part) => part.thought === true);
 }
 __name(hasThoughtPart, "hasThoughtPart");
+var THINKING_TAG_PATTERN = /<\/?think(?:ing)?\s*>/i;
+var CLOSING_THINKING_TAG_PATTERN = /\n[^\S\r\n]*<\/think(?:ing)?[^\S\r\n]*>/i;
+var LEADING_CLOSING_THINKING_TAG_PATTERN = /^[^\S\r\n]*<\/think(?:ing)?[^\S\r\n]*>/i;
+var LEADING_THINKING_TAG_PATTERN = /^\s*<\/?think(?:ing)?\s*>/i;
 function convertOpenAIResponseToGemini(openaiResponse, requestContext) {
   const choice = openaiResponse.choices?.[0];
   const response = new GenerateContentResponse();
@@ -64913,7 +64931,7 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
     );
   }
   if (choice) {
-    const parts = [];
+    let parts = [];
     let contentParts = [];
     const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
     if (typeof choice.delta?.content === "string") {
@@ -64958,6 +64976,12 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
           cumulativeMode: false
         }
       );
+      if (normalizedReasoningText) {
+        requestContext.hasStructuredReasoningContent = true;
+        if (THINKING_TAG_PATTERN.test(normalizedReasoningText)) {
+          requestContext.hasThinkingTagInReasoning = true;
+        }
+      }
       if (normalizedReasoningText && !requestContext.responseParsingOptions?.taggedThinkingTags) {
         parts.push(createOpenAIReasoningThoughtPart(normalizedReasoningText));
       } else if (normalizedReasoningText && !requestContext.hasTaggedThinkingThought) {
@@ -65015,10 +65039,45 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
         }
       }
     }
+    const visibleText = parts.map(
+      (part) => part.thought !== true && typeof part.text === "string" ? part.text : ""
+    ).join("");
+    const leakedThinkingTag = requestContext.hasStructuredReasoningContent === true && (requestContext.hasVisibleContent !== true && LEADING_THINKING_TAG_PATTERN.test(visibleText) || requestContext.hasThinkingTagInReasoning === true && (CLOSING_THINKING_TAG_PATTERN.test(visibleText) || requestContext.atVisibleLineStart === true && LEADING_CLOSING_THINKING_TAG_PATTERN.test(visibleText)));
+    if (/\S/.test(visibleText)) {
+      requestContext.hasVisibleContent = true;
+    }
+    if (visibleText && requestContext.hasThinkingTagInReasoning === true) {
+      const lastLineBreak = visibleText.lastIndexOf("\n");
+      const lineSuffix = visibleText.slice(lastLineBreak + 1);
+      requestContext.atVisibleLineStart = (lastLineBreak >= 0 || requestContext.atVisibleLineStart === true) && /^[^\S\r\n]*$/.test(lineSuffix);
+    }
+    if (leakedThinkingTag) {
+      requestContext.pendingUntrustedResponseParts = void 0;
+      throw new InvalidStreamError(
+        "Model response leaked thinking tags.",
+        "PROTOCOL_TAG_LEAK"
+      );
+    }
+    const toolCallWithoutName = toolCallParser.hasNamelessToolCall();
+    const completedToolCalls = choice.finish_reason ? toolCallParser.getCompletedToolCalls() : [];
+    if (choice.finish_reason && (toolCallWithoutName || choice.finish_reason === "tool_calls" && completedToolCalls.length === 0)) {
+      requestContext.pendingUntrustedResponseParts = void 0;
+      throw new InvalidStreamError(
+        "Model response contained a malformed tool call.",
+        "MALFORMED_TOOL_CALL"
+      );
+    }
+    const shouldHoldParts = !choice.finish_reason && (toolCallWithoutName || requestContext.hasThinkingTagInReasoning === true);
+    if (shouldHoldParts) {
+      (requestContext.pendingUntrustedResponseParts ??= []).push(...parts);
+      parts.length = 0;
+    } else if (requestContext.pendingUntrustedResponseParts) {
+      parts = requestContext.pendingUntrustedResponseParts.concat(parts);
+      requestContext.pendingUntrustedResponseParts = void 0;
+    }
     let toolCallsTruncated = false;
     if (choice.finish_reason) {
       toolCallsTruncated = toolCallParser.hasIncompleteToolCalls();
-      const completedToolCalls = toolCallParser.getCompletedToolCalls();
       for (const toolCall of completedToolCalls) {
         if (toolCall.name) {
           parts.push({
@@ -68362,6 +68421,44 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
 };
 var uiTelemetryService = new UiTelemetryService();
 
+// packages/core/src/telemetry/api-activity-tracker.ts
+init_esbuild_shims();
+var ApiActivityTracker = class {
+  static {
+    __name(this, "ApiActivityTracker");
+  }
+  #errors = 0;
+  #retries = 0;
+  /** Fold in one model API error (called from `logApiError`). */
+  recordError() {
+    this.#errors += 1;
+  }
+  /** Fold in one automatic retry (called from `logApiRetry`). */
+  recordRetry() {
+    this.#retries += 1;
+  }
+  /**
+   * Return the counts accumulated since the last drain and reset them to zero.
+   * The read+reset is synchronous (no `await` between), so a `recordError` /
+   * `recordRetry` racing an in-progress drain can never be lost — it simply
+   * lands in the next window.
+   */
+  drain() {
+    const counts = {
+      errors: this.#errors,
+      retries: this.#retries
+    };
+    this.#errors = 0;
+    this.#retries = 0;
+    return counts;
+  }
+  /** Peek at the pending counts without draining (tests / diagnostics). */
+  peek() {
+    return { errors: this.#errors, retries: this.#retries };
+  }
+};
+var apiActivityTracker = new ApiActivityTracker();
+
 // packages/core/src/telemetry/daemon-tracing.ts
 init_esbuild_shims();
 init_esm();
@@ -70061,11 +70158,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-6I7DKUAN.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-XNS5S64I.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
       const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-LEYOU7RU.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-5DDIXI2N.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-APDPJ3VN.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -70086,7 +70183,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-56U3YCP2.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-GE3HPIFB.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-G6UCE6MW.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -71811,6 +71908,7 @@ function logApiError(config, event) {
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   uiTelemetryService.addEvent(uiEvent, config.getSessionId());
+  apiActivityTracker.recordError();
   if (!isInternalPromptId(event.prompt_id)) {
     recordUiTelemetryEventToChat(config, uiEvent);
   }
@@ -72077,6 +72175,7 @@ function logContentRetryFailure(config, event) {
 }
 __name(logContentRetryFailure, "logContentRetryFailure");
 function logApiRetry(config, event) {
+  apiActivityTracker.recordRetry();
   QwenLogger.getInstance(config)?.logApiRetryEvent(event);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
@@ -72989,6 +73088,7 @@ export {
   refreshSessionContext,
   shutdownTelemetry,
   forceFlushMetrics,
+  apiActivityTracker,
   _recoverObjectsFromLine,
   parseLineTolerant,
   readLines,
@@ -73124,6 +73224,7 @@ export {
   parseThought,
   getThoughtSummary,
   TaggedThinkingParser,
+  InvalidStreamError,
   OpenAIContentConverter,
   openaiRequestCaptureContext,
   isApiError,

package/chunks/{chunk-GYGGUR4Q.js → chunk-Q5GLXH5Q.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-6HHAADP2.js";
+} from "./chunk-AAR5SGMD.js";
 import {
   getPlugin,
   parseChannelConfig,
@@ -13,14 +13,14 @@ import {
 } from "./chunk-SXU3KKNI.js";
 import {
   loadSettings
-} from "./chunk-T2L6SGQY.js";
+} from "./chunk-6GETGQWP.js";
 import {
   writeStderrLine,
   writeStdoutLine
 } from "./chunk-YUZI3WAC.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-T7FSRWQ5.js";
+} from "./chunk-P6LART6G.js";
 import {
   Storage
 } from "./chunk-7NFB7LBQ.js";

package/chunks/{chunk-SE74CIZD.js → chunk-RDRVMDWV.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-YUZI3WAC.js";
 import {
   resolveBundleDir
-} from "./chunk-SSFDPGFN.js";
+} from "./chunk-K7CRWKOE.js";
 import {
   Storage
 } from "./chunk-7NFB7LBQ.js";

package/chunks/{chunk-DKXW66XA.js → chunk-SPUYQB4T.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-SE74CIZD.js";
+} from "./chunk-RDRVMDWV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-AGBFWLA5.js → chunk-TISZXPAX.js}

@@ -60,7 +60,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./src-55DZWDAK.js");
+  const { Storage } = await import("./src-USZKPUOC.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");