@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{chunk-BXDAPVQU.js → chunk-L6CUJZDG.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   MAX_INLINE_IMAGE_ENCODED_LENGTH
-} from "./chunk-TPI7O7HR.js";
+} from "./chunk-7DDTI7Q3.js";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -859,6 +859,8 @@ var renderCache = /* @__PURE__ */ new Map();
 var renderCacheBytes = 0;
 var INLINE_DECODE_CACHE_LIMIT = 4;
 var inlineDecodeCache = /* @__PURE__ */ new Map();
+var INLINE_DECODE_NEGATIVE_CACHE_LIMIT = 64;
+var invalidInlineImageCache = /* @__PURE__ */ new Set();
 var TRANSMITTED_KEY_LIMIT = 256;
 var transmittedKeys = /* @__PURE__ */ new Set();
 function wasKittyImageWritten(key) {
@@ -1080,10 +1082,22 @@ function getDecodedInlinePng(data) {
     inlineDecodeCache.set(data, cached);
     return cached;
   }
+  const negativeKey = crypto2.createHash("sha256").update(data).digest("hex");
+  if (invalidInlineImageCache.has(negativeKey)) {
+    invalidInlineImageCache.delete(negativeKey);
+    invalidInlineImageCache.add(negativeKey);
+    return null;
+  }
   const png = decodeInlineImage(data);
-  if (!png) return null;
+  if (!png) {
+    cacheInvalidInlineImage(negativeKey);
+    return null;
+  }
   const size = readValidatedInlinePngSize(png);
-  if (!size) return null;
+  if (!size) {
+    cacheInvalidInlineImage(negativeKey);
+    return null;
+  }
   const decoded = { png, size };
   inlineDecodeCache.set(data, decoded);
   while (inlineDecodeCache.size > INLINE_DECODE_CACHE_LIMIT) {
@@ -1094,6 +1108,15 @@ function getDecodedInlinePng(data) {
   return decoded;
 }
 __name(getDecodedInlinePng, "getDecodedInlinePng");
+function cacheInvalidInlineImage(key) {
+  invalidInlineImageCache.add(key);
+  while (invalidInlineImageCache.size > INLINE_DECODE_NEGATIVE_CACHE_LIMIT) {
+    const oldest = invalidInlineImageCache.values().next().value;
+    if (oldest === void 0) break;
+    invalidInlineImageCache.delete(oldest);
+  }
+}
+__name(cacheInvalidInlineImage, "cacheInvalidInlineImage");
 function readValidatedInlinePngSize(png) {
   if (png.length < 24 || png.readUInt32BE(8) !== 13 || png.subarray(12, 16).toString("ascii") !== "IHDR") {
     return null;
@@ -1261,6 +1284,7 @@ __name(firstLineBounded, "firstLineBounded");
 export {
   renderMermaidImageAsync,
   MAX_INLINE_IMAGE_PIXELS,
+  INLINE_DECODE_NEGATIVE_CACHE_LIMIT,
   TRANSMITTED_KEY_LIMIT,
   wasKittyImageWritten,
   markKittyImageWritten,

package/chunks/chunk-LAUEEBDL.js

@@ -0,0 +1,277 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  normalizeSessionIdForLookup
+} from "./chunk-ZEZKIS2K.js";
+import {
+  MAX_WORKSPACE_PATH_LENGTH,
+  translateAndCheckAbsoluteWorkspacePath
+} from "./chunk-6PLDPT2C.js";
+import {
+  writeStderrLine
+} from "./chunk-7FA2II6K.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/server/request-helpers.ts
+init_esbuild_shims();
+function sendJsonBodyParserError(res, err) {
+  if (err instanceof SyntaxError && "status" in err && err.status === 400) {
+    res.status(400).json({ error: "Invalid JSON in request body" });
+    return true;
+  }
+  if (err && typeof err === "object" && "status" in err && err.status === 413) {
+    res.status(413).json({ error: "Request body too large (max 10 MB)" });
+    return true;
+  }
+  return false;
+}
+__name(sendJsonBodyParserError, "sendJsonBodyParserError");
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var CLIENT_ID_HEADER = "x-qwen-client-id";
+var MAX_CLIENT_ID_LENGTH = 128;
+var MAX_TOOL_NAME_LENGTH = 256;
+var MAX_SKILL_NAME_LENGTH = 256;
+var MAX_SERVER_NAME_LENGTH = 256;
+var CLIENT_ID_RE = /^[A-Za-z0-9._:-]+$/;
+var INVALID_PERMISSION_OUTCOME_ERROR = '`outcome` must be `{ outcome: "cancelled" }` or `{ outcome: "selected", optionId: string }`';
+var deferredRuntimeTimingKey = Symbol(
+  "deferredRuntimeRequestTiming"
+);
+function setDeferredRuntimeRequestTiming(req, timing) {
+  req[deferredRuntimeTimingKey] = timing;
+}
+__name(setDeferredRuntimeRequestTiming, "setDeferredRuntimeRequestTiming");
+function getDeferredRuntimeRequestTiming(req) {
+  return req[deferredRuntimeTimingKey];
+}
+__name(getDeferredRuntimeRequestTiming, "getDeferredRuntimeRequestTiming");
+function safeBody(req) {
+  const raw = req.body;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(raw)) {
+    if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+__name(safeBody, "safeBody");
+function parseOptionalWorkspaceCwd(body, boundWorkspace, res) {
+  const hasCwd = "cwd" in body;
+  if (hasCwd && typeof body["cwd"] !== "string") {
+    res.status(400).json({ error: "`cwd` must be a string absolute path when provided" });
+    return void 0;
+  }
+  if (hasCwd && body["cwd"].length > MAX_WORKSPACE_PATH_LENGTH) {
+    res.status(400).json({
+      error: `\`cwd\` exceeds the ${MAX_WORKSPACE_PATH_LENGTH}-character limit`
+    });
+    return void 0;
+  }
+  const cwd = translateAndCheckAbsoluteWorkspacePath(
+    hasCwd ? body["cwd"] : boundWorkspace
+  );
+  if (cwd === null) {
+    res.status(400).json({ error: "`cwd` must be an absolute path when provided" });
+    return void 0;
+  }
+  return cwd;
+}
+__name(parseOptionalWorkspaceCwd, "parseOptionalWorkspaceCwd");
+function requireSessionId(req, res) {
+  const sessionId = req.params["id"];
+  if (!sessionId) {
+    res.status(400).json({ error: "`sessionId` route parameter is required" });
+    return null;
+  }
+  return normalizeSessionIdForLookup(sessionId);
+}
+__name(requireSessionId, "requireSessionId");
+function parseClientIdHeader(req, res) {
+  const raw = req.get(CLIENT_ID_HEADER);
+  if (raw === void 0 || raw === "") return void 0;
+  if (raw.length > MAX_CLIENT_ID_LENGTH || !CLIENT_ID_RE.test(raw)) {
+    res.status(400).json({
+      error: "`X-Qwen-Client-Id` must be a non-empty token of 128 characters or fewer",
+      code: "invalid_client_id"
+    });
+    return null;
+  }
+  return raw;
+}
+__name(parseClientIdHeader, "parseClientIdHeader");
+function detectFromLoopback(req) {
+  const addr = req.socket?.remoteAddress;
+  if (typeof addr !== "string") return false;
+  if (addr === "::1") return true;
+  if (addr.startsWith("127.")) return true;
+  if (addr.startsWith("::ffff:127.")) return true;
+  return false;
+}
+__name(detectFromLoopback, "detectFromLoopback");
+function validateMcpRuntimeServerName(name, res) {
+  if (typeof name !== "string" || name.length === 0) {
+    res.status(400).json({
+      error: "Server name is required and must be a non-empty string",
+      code: "invalid_server_name"
+    });
+    return false;
+  }
+  if (name.length > MAX_SERVER_NAME_LENGTH) {
+    res.status(400).json({
+      error: `Server name exceeds ${MAX_SERVER_NAME_LENGTH}-character limit`,
+      code: "invalid_server_name"
+    });
+    return false;
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+    res.status(400).json({
+      error: "Server name must contain only alphanumeric characters, underscores, and hyphens",
+      code: "invalid_server_name"
+    });
+    return false;
+  }
+  if (name === "__proto__" || name === "constructor" || name === "prototype") {
+    res.status(400).json({
+      error: "Server name must not be a reserved JS property name",
+      code: "invalid_server_name"
+    });
+    return false;
+  }
+  return true;
+}
+__name(validateMcpRuntimeServerName, "validateMcpRuntimeServerName");
+function parseAndValidateWorkspaceClientId(req, res, bridge) {
+  const raw = parseClientIdHeader(req, res);
+  if (raw === null || raw === void 0) return raw;
+  const bridges = Array.isArray(bridge) ? bridge : [bridge];
+  if (!bridges.some((candidate) => candidate.knownClientIds().has(raw))) {
+    res.status(400).json({
+      error: `Client id "${raw}" is not registered for this workspace`,
+      code: "invalid_client_id",
+      clientId: raw
+    });
+    return null;
+  }
+  return raw;
+}
+__name(parseAndValidateWorkspaceClientId, "parseAndValidateWorkspaceClientId");
+function createBuildWorkspaceCtx(boundWorkspace) {
+  return (route, clientId) => ({
+    originatorClientId: clientId,
+    route,
+    workspaceCwd: boundWorkspace
+  });
+}
+__name(createBuildWorkspaceCtx, "createBuildWorkspaceCtx");
+function parsePermissionVoteBody(req, res) {
+  const body = safeBody(req);
+  const outcome = body["outcome"];
+  if (!isValidOutcome(outcome)) {
+    res.status(400).json({ error: INVALID_PERMISSION_OUTCOME_ERROR });
+    return void 0;
+  }
+  return {
+    ...body,
+    outcome
+  };
+}
+__name(parsePermissionVoteBody, "parsePermissionVoteBody");
+function isValidOutcome(raw) {
+  if (typeof raw !== "object" || raw === null) return false;
+  const obj = raw;
+  if (obj["outcome"] === "cancelled") return true;
+  return obj["outcome"] === "selected" && typeof obj["optionId"] === "string" && obj["optionId"].length > 0;
+}
+__name(isValidOutcome, "isValidOutcome");
+var MIN_QUERY_MAX_QUEUED = 16;
+var MAX_QUERY_MAX_QUEUED = 2048;
+function parseMaxQueuedQuery(raw, res) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
+    writeStderrLine(
+      `qwen serve: rejected ?maxQueued ${safeLogValue(raw)} (not a decimal integer)`
+    );
+    res.status(400).json({
+      error: "`maxQueued` must be a decimal integer",
+      code: "invalid_max_queued"
+    });
+    return null;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < MIN_QUERY_MAX_QUEUED || n > MAX_QUERY_MAX_QUEUED) {
+    writeStderrLine(
+      `qwen serve: rejected ?maxQueued ${safeLogValue(raw)} (outside [${MIN_QUERY_MAX_QUEUED}, ${MAX_QUERY_MAX_QUEUED}])`
+    );
+    res.status(400).json({
+      error: `\`maxQueued\` must be in [${MIN_QUERY_MAX_QUEUED}, ${MAX_QUERY_MAX_QUEUED}]`,
+      code: "invalid_max_queued"
+    });
+    return null;
+  }
+  return n;
+}
+__name(parseMaxQueuedQuery, "parseMaxQueuedQuery");
+function safeLogValue(raw) {
+  return JSON.stringify(String(raw)).slice(0, 82);
+}
+__name(safeLogValue, "safeLogValue");
+function parseLastEventId(raw) {
+  if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
+    if (typeof raw === "string" && raw.length > 0) {
+      writeStderrLine(
+        `qwen serve: rejected Last-Event-ID ${safeLogValue(raw)} (not a decimal integer)`
+      );
+    }
+    return void 0;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n > Number.MAX_SAFE_INTEGER) {
+    writeStderrLine(
+      `qwen serve: rejected Last-Event-ID ${safeLogValue(raw)} (exceeds Number.MAX_SAFE_INTEGER)`
+    );
+    return void 0;
+  }
+  return n;
+}
+__name(parseLastEventId, "parseLastEventId");
+
+export {
+  sendJsonBodyParserError,
+  CLIENT_ID_HEADER,
+  MAX_CLIENT_ID_LENGTH,
+  MAX_TOOL_NAME_LENGTH,
+  MAX_SKILL_NAME_LENGTH,
+  MAX_SERVER_NAME_LENGTH,
+  CLIENT_ID_RE,
+  setDeferredRuntimeRequestTiming,
+  getDeferredRuntimeRequestTiming,
+  safeBody,
+  parseOptionalWorkspaceCwd,
+  requireSessionId,
+  parseClientIdHeader,
+  detectFromLoopback,
+  validateMcpRuntimeServerName,
+  parseAndValidateWorkspaceClientId,
+  createBuildWorkspaceCtx,
+  parsePermissionVoteBody,
+  parseMaxQueuedQuery,
+  safeLogValue,
+  parseLastEventId
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BNMF3K5X.js → chunk-LFAR7CPW.js}

@@ -3,17 +3,17 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-TRZTNIQ6.js";
+} from "./chunk-JOWQD4LO.js";
 import {
   handleAtCommand,
   normalizePartList
-} from "./chunk-OIP7C4FE.js";
+} from "./chunk-AKNQMSL2.js";
 import {
   JsonOutputAdapter
-} from "./chunk-JU4EEXC7.js";
+} from "./chunk-XLENZQXH.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-6LFJEACX.js";
+} from "./chunk-MZ5A5PQW.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,11 +24,11 @@ import {
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand
-} from "./chunk-F5SZP77N.js";
+} from "./chunk-BBYTY46C.js";
 import {
   RunBudgetEnforcer,
   cleanupReviewWorktreeLeases
-} from "./chunk-BAJKAAOY.js";
+} from "./chunk-YOMKOM7E.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -36,20 +36,20 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-L6YT5H34.js";
+} from "./chunk-MJBHSZEJ.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-Q26AYA62.js";
+} from "./chunk-W7KWB6AH.js";
 import {
   buildGoalContinuationParts,
   buildSessionRecoveryPlanFromApiHistory,
   detectAutonomousSentinel,
   detectLoopSentinel,
   executeToolCall
-} from "./chunk-KUX5D6DK.js";
+} from "./chunk-NT7LXVV5.js";
 import {
   restoreWorktreeContext
-} from "./chunk-OIVXBW3W.js";
+} from "./chunk-ED7DD7MV.js";
 import {
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   clampInlineMediaPart,
@@ -58,25 +58,26 @@ import {
   findPlanModeEntryBatchBoundaryIndex,
   findRepeatedDuplicateProviderToolCall,
   getCachedToolCallFingerprint,
+  goalToolResultProvenance,
   isReplayOfHandledToolCall,
   isToolCallConcurrencySafe,
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
   partitionByConcurrencySafety,
   recordHandledToolCall
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-ZBDYI7VM.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
 import {
   promptIdContext
 } from "./chunk-O6GEWCJA.js";
-import {
-  GoalPersistenceUnavailableError
-} from "./chunk-WKK5BQNP.js";
 import {
   addAgentOutputMessageAttributes
-} from "./chunk-7DJCPZE3.js";
+} from "./chunk-OSTQZIOY.js";
+import {
+  GoalPersistenceUnavailableError
+} from "./chunk-4P7PPAHN.js";
 import {
   formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
@@ -86,28 +87,28 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-L2M46FP5.js";
+} from "./chunk-FXUSWLBF.js";
 import {
   endInteractionSpan,
   getActiveInteractionSpan,
   isTelemetrySdkInitialized,
   shutdownTelemetry
-} from "./chunk-L6BZRIUL.js";
+} from "./chunk-TBJ3SNS3.js";
 import {
   isSystemReminderContent
-} from "./chunk-CAJTKR6W.js";
+} from "./chunk-D7D3HSYQ.js";
 import {
   ToolNames,
   canonicalToolName
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   FatalInputError,
   createDebugLogger,
   getErrorType
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   registerCleanup
-} from "./chunk-Y6LSMB6J.js";
+} from "./chunk-TV7BJ7TX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -356,7 +357,7 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
         ...metadata
       });
     }, "endActiveInteraction");
-    const geminiClient = config.getGeminiClient();
+    const llmClient = config.getLlmClient();
     const abortController = options.abortController ?? new AbortController();
     const queuedGoalTurns = [];
     let activeGoalTurn;
@@ -400,6 +401,7 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
           controller: new AbortController(),
           origin: "runtime",
           continuationContext: input2.continuationContext,
+          ...input2.objectiveUpdated ? { objectiveUpdated: input2.objectiveUpdated } : {},
           ...input2.windDown ? { windDown: true } : {},
           ...input2.verifierFeedback ? { verifierFeedback: input2.verifierFeedback } : {}
         });
@@ -414,6 +416,12 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     const bindGoalHost = /* @__PURE__ */ __name(() => {
       goalHostUnbind ??= config.bindGoalTurnHost(goalHost);
     }, "bindGoalHost");
+    const markGoalTurnDelivered = /* @__PURE__ */ __name((turn) => {
+      try {
+        config.getGoalRuntime().markTurnDelivered(turn.turnKey);
+      } catch {
+      }
+    }, "markGoalTurnDelivered");
     let settlingGoalTurn;
     let goalTurnSettlement;
     const failClosedActiveGoalTurn = /* @__PURE__ */ __name((reason) => {
@@ -679,7 +687,7 @@ ${reason}
       if (options.continueInterrupted) {
         const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({
           sessionId,
-          apiHistory: geminiClient.getChat().getHistory()
+          apiHistory: llmClient.getChat().getHistory()
         });
         debugLogger.info("[runNonInteractive] continueInterrupted recovery", {
           kind: recoveryPlan.kind,
@@ -784,6 +792,7 @@ ${reason}
                   "The Goal runtime did not schedule a continuation."
                 );
               }
+              markGoalTurnDelivered(activeGoalTurn);
               initialPartList = buildGoalContinuationParts(activeGoalTurn);
               slashHandled = true;
               break;
@@ -1129,7 +1138,7 @@ ${text}
         return 1;
       }, "emitLoopDetectedResult");
       const handledToolCallFingerprints = new Map(
-        geminiClient.getHistoryToolCallFingerprints()
+        llmClient.getHistoryToolCallFingerprints()
       );
       const duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
       const processToolCallBatch = /* @__PURE__ */ __name(async (batchRequests, setModelOverride, runtimeView) => {
@@ -1291,7 +1300,7 @@ ${text}
           adapter.emitToolResult(requestInfo, toolResponse);
           responseByRequest.set(requestInfo, toolResponse);
           terminateTurn ||= toolResponse.terminateTurn === true;
-          config.getGeminiClient().recordCompletedToolCall(
+          config.getLlmClient().recordCompletedToolCall(
             requestInfo.name,
             requestInfo.args
           );
@@ -1469,16 +1478,21 @@ ${text}
           const { request, response } = orderedResponses[index];
           const finalizedParts = finalized[index].responseParts;
           toolResponseParts.push(...finalizedParts);
-          chatRecordingService?.recordToolResult?.(finalizedParts, {
-            callId: request.callId,
-            status: statusByResponse.get(response) ?? (response.error ? "error" : "success"),
-            resultDisplay: response.resultDisplay,
-            persistedOutputFiles: finalized[index].persistedOutputFiles,
-            artifacts: finalized[index].artifacts,
-            error: response.error,
-            errorType: response.errorType,
-            executionStatus: response.executionStatus
-          });
+          const goalProvenance = goalToolResultProvenance(request);
+          chatRecordingService?.recordToolResult?.(
+            finalizedParts,
+            {
+              callId: request.callId,
+              status: statusByResponse.get(response) ?? (response.error ? "error" : "success"),
+              resultDisplay: response.resultDisplay,
+              persistedOutputFiles: finalized[index].persistedOutputFiles,
+              artifacts: finalized[index].artifacts,
+              error: response.error,
+              errorType: response.errorType,
+              executionStatus: response.executionStatus
+            },
+            ...goalProvenance ? [goalProvenance] : []
+          );
         }
         return {
           responseParts: toolResponseParts,
@@ -1529,7 +1543,7 @@ ${text}
         );
         const toolCallRequests = [];
         const apiStartTime = Date.now();
-        const responseStream = geminiClient.sendMessageStream(
+        const responseStream = llmClient.sendMessageStream(
           currentMessages[0]?.parts || [],
           abortController.signal,
           currentPromptId,
@@ -1625,7 +1639,7 @@ ${text}
             return emitLoopDetectedResult();
           }
           if (terminateTurn && activeGoalTurn) {
-            geminiClient.addHistory({
+            llmClient.addHistory({
               role: "user",
               parts: toolResponseParts
             });
@@ -1637,6 +1651,7 @@ ${text}
             const nextGoalTurn = queuedGoalTurns.shift();
             if (nextGoalTurn) {
               activeGoalTurn = nextGoalTurn;
+              markGoalTurnDelivered(nextGoalTurn);
               isFirstGoalSegment = true;
               currentMessages = [
                 {
@@ -1667,6 +1682,7 @@ ${text}
             const nextGoalTurn = queuedGoalTurns.shift();
             if (nextGoalTurn) {
               activeGoalTurn = nextGoalTurn;
+              markGoalTurnDelivered(nextGoalTurn);
               isFirstGoalSegment = true;
               currentMessages = [
                 {
@@ -1751,7 +1767,7 @@ ${text}
               const itemToolCallRequests = [];
               const itemApiStartTime = Date.now();
               selectActiveInteraction(itemPromptId, itemIsFirstTurn);
-              const itemStream = geminiClient.sendMessageStream(
+              const itemStream = llmClient.sendMessageStream(
                 itemMessages[0]?.parts || [],
                 abortController.signal,
                 itemPromptId,
@@ -1928,7 +1944,7 @@ ${text}
               break;
             await new Promise((r) => setTimeout(r, 100));
           }
-          const memoryTaskPromises = config.getGeminiClient().consumePendingMemoryTaskPromises();
+          const memoryTaskPromises = config.getLlmClient().consumePendingMemoryTaskPromises();
           if (memoryTaskPromises.length > 0) {
             await Promise.allSettled(memoryTaskPromises);
           }

package/chunks/{chunk-Y3QL45LS.js → chunk-LKODFJRD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -716,7 +716,7 @@ function anthropicTools(value) {
   return result;
 }
 __name(anthropicTools, "anthropicTools");
-function geminiTools(value) {
+function llmTools(value) {
   if (!Array.isArray(value)) return void 0;
   const result = [];
   for (const wrapper of value) {
@@ -734,7 +734,7 @@ function geminiTools(value) {
   }
   return result;
 }
-__name(geminiTools, "geminiTools");
+__name(llmTools, "llmTools");
 function extractOpenAiContent(request) {
   const value = request;
   return {
@@ -756,7 +756,7 @@ function extractAnthropicContent(request) {
   };
 }
 __name(extractAnthropicContent, "extractAnthropicContent");
-function extractGeminiContent(request) {
+function extractLlmContent(request) {
   const value = request;
   const config = record(value["config"]);
   return {
@@ -766,10 +766,10 @@ function extractGeminiContent(request) {
       (role) => role === "model" ? "assistant" : role
     ) : void 0,
     systemInstructions: config && Object.hasOwn(config, "systemInstruction") ? systemParts(config["systemInstruction"], geminiPart) : void 0,
-    toolDefinitions: config && Object.hasOwn(config, "tools") ? geminiTools(config["tools"]) : void 0
+    toolDefinitions: config && Object.hasOwn(config, "tools") ? llmTools(config["tools"]) : void 0
   };
 }
-__name(extractGeminiContent, "extractGeminiContent");
+__name(extractLlmContent, "extractLlmContent");
 function stringifyGenAiJson(value, maxLength, requireObject = false) {
   const converted = jsonValue(value);
   if (converted === void 0 || requireObject && (converted === null || Array.isArray(converted) || typeof converted !== "object")) {
@@ -1032,7 +1032,7 @@ var GenAiOutputAccumulator = class {
       if (finishReason) candidate.finishReason = finishReason;
     }
   }
-  recordGeminiResponse(response) {
+  recordLlmResponse(response) {
     const candidates = response["candidates"];
     if (!Array.isArray(candidates)) return;
     this.observedResponse = true;
@@ -1061,7 +1061,7 @@ var GenAiOutputAccumulator = class {
       if (finishReason) outputCandidate.finishReason = finishReason;
     }
   }
-  recordGeminiChunk(chunk) {
+  recordLlmChunk(chunk) {
     const candidates = chunk["candidates"];
     if (!Array.isArray(candidates)) return;
     this.observedResponse = true;
@@ -1241,7 +1241,7 @@ var GenAiOutputAccumulator = class {
 export {
   extractOpenAiContent,
   extractAnthropicContent,
-  extractGeminiContent,
+  extractLlmContent,
   stringifyGenAiJson,
   GenAiOutputAccumulator
 };