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

package/chunks/{loggingContentGenerator-2GGZNGLG.js → loggingContentGenerator-QYYYGU6V.js}

@@ -2,64 +2,124 @@
 "use strict";
 import {
   OpenAILogger
-} from "./chunk-MIIVI25Q.js";
+} from "./chunk-JDIO45X7.js";
+import {
+  computeThresholds,
+  estimateContentTokens,
+  estimateContextTextTokens
+} from "./chunk-ZBDYI7VM.js";
+import "./chunk-GOFAQQZA.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-6HUXPLB5.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-CQ35AJ4Z.js";
+import "./chunk-SMJYTKTB.js";
+import "./chunk-AI35S34R.js";
+import "./chunk-FIWZOMBF.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-OKTNXDVO.js";
+import "./chunk-DJBQCO2E.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-UJ4DUYIH.js";
+import "./chunk-O6GEWCJA.js";
+import {
+  getCustomSystemPrompt
+} from "./chunk-YDQ4OCDK.js";
+import "./chunk-SDCHI64N.js";
+import "./chunk-B2RIIK3K.js";
+import "./chunk-373DQUVA.js";
 import {
   areSensitiveSpanAttributesEnabled
-} from "./chunk-7DJCPZE3.js";
+} from "./chunk-OSTQZIOY.js";
+import "./chunk-U6D2PPMN.js";
+import "./chunk-PDXYZBBQ.js";
+import "./chunk-QJNDUTOL.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-AF3QB6OL.js";
+import "./chunk-7TBU7PU2.js";
+import "./chunk-E4JNFXNI.js";
+import "./chunk-4P7PPAHN.js";
+import "./chunk-7J6OTNGO.js";
+import "./chunk-CHEIIBT3.js";
+import "./chunk-VYSZUQGU.js";
+import "./chunk-JX6XHPTX.js";
+import "./chunk-MLXTMF7H.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-KFN2IZYR.js";
 import {
   retryContext
-} from "./chunk-P3QQPMQA.js";
-import "./chunk-HVEYF6VT.js";
+} from "./chunk-GB4UKWY5.js";
+import "./chunk-QHMLYMMS.js";
+import "./chunk-UXEW7TQS.js";
 import {
   OpenAIContentConverter,
   openaiRequestCaptureContext
-} from "./chunk-4J657AJR.js";
+} from "./chunk-ID33ZRWH.js";
 import {
   getGenAiUsageProvenance
-} from "./chunk-ABS25QER.js";
+} from "./chunk-ANVG3BVV.js";
 import {
   runtimeDiagnostics
 } from "./chunk-VNOVK4I7.js";
 import {
   createGenAiExchange
-} from "./chunk-B7CDU2SL.js";
-import "./chunk-K2OJUPOE.js";
+} from "./chunk-MOF6VZN2.js";
+import "./chunk-PQEISIKS.js";
+import "./chunk-RT4QNQ5P.js";
+import "./chunk-26SIKQIC.js";
+import "./chunk-S6LOFUVP.js";
 import "./chunk-CFKIH3D3.js";
-import "./chunk-4FTKQNWJ.js";
-import "./chunk-Y3QL45LS.js";
+import "./chunk-2LD5U7Q3.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
 import {
   ApiErrorEvent,
   ApiRequestEvent,
   ApiResponseEvent,
+  DiscoveredMCPTool,
   isInternalPromptId,
   logApiError,
   logApiRequest,
   logApiResponse,
   subagentIdentityContext,
   subagentNameContext
-} from "./chunk-L2M46FP5.js";
-import "./chunk-YRLW2MSX.js";
+} from "./chunk-FXUSWLBF.js";
+import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-3I6UTTDX.js";
-import "./chunk-6PJOTWAN.js";
-import "./chunk-BWORX6FA.js";
+import "./chunk-67AY5D3M.js";
+import "./chunk-HT5S5TRQ.js";
+import "./chunk-LMMHS3RS.js";
 import "./chunk-WZAD4ZNJ.js";
-import "./chunk-FPGTNKCP.js";
-import "./chunk-6DIGWMGT.js";
-import "./chunk-Z7FLBQPR.js";
+import {
+  DEFAULT_TOKEN_LIMIT
+} from "./chunk-FPGTNKCP.js";
+import "./chunk-EIJT2PQ6.js";
+import "./chunk-H5GPPDGY.js";
 import "./chunk-XZA32HII.js";
-import "./chunk-23RFD54N.js";
-import "./chunk-PPKZ7JOE.js";
+import "./chunk-KHP66DFN.js";
+import "./chunk-22UH7VTP.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   API_CALL_ABORTED_SPAN_STATUS_MESSAGE,
   API_CALL_FAILED_SPAN_STATUS_MESSAGE,
   endLLMRequestSpan,
+  isTelemetrySdkInitialized,
+  isValidContextUsage,
   startLLMRequestSpanWithContext
-} from "./chunk-L6BZRIUL.js";
+} from "./chunk-TBJ3SNS3.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-XF63PKEN.js";
-import "./chunk-UTLCH2FK.js";
+import "./chunk-IXHV5MIC.js";
+import "./chunk-D7D3HSYQ.js";
+import {
+  buildSkillLlmContent
+} from "./chunk-YKADANK6.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-ODZF64DM.js";
+import {
+  ToolNames
+} from "./chunk-LYSZVCCD.js";
 import {
   createDebugLogger,
   getErrorMessage,
@@ -67,7 +127,7 @@ import {
   getErrorType,
   getSessionIdFromContext,
   isAbortError
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -95,6 +155,209 @@ init_esbuild_shims();
 init_esbuild_shims();
 init_esm();
 
+// packages/core/src/core/loggingContentGenerator/context-usage-snapshot.ts
+init_esbuild_shims();
+import * as path from "node:path";
+function toPart(part) {
+  return typeof part === "string" ? { text: part } : part;
+}
+__name(toPart, "toPart");
+function toContent(content) {
+  if (Array.isArray(content)) {
+    return { role: "user", parts: content.map(toPart) };
+  }
+  if (typeof content === "string") {
+    return { role: "user", parts: [{ text: content }] };
+  }
+  if ("parts" in content) {
+    return {
+      ...content,
+      parts: content.parts?.filter((part) => part != null).map(toPart) ?? []
+    };
+  }
+  return { role: "user", parts: [toPart(content)] };
+}
+__name(toContent, "toContent");
+function toContents(contents) {
+  return Array.isArray(contents) ? contents.map((content) => toContent(content)) : [toContent(contents)];
+}
+__name(toContents, "toContents");
+function requestFunctionDeclarations(request) {
+  const declarations = [];
+  for (const tool of request.config?.tools ?? []) {
+    if (typeof tool === "object" && tool !== null && "tool" in tool) {
+      return void 0;
+    }
+    if (typeof tool === "object" && tool !== null && "functionDeclarations" in tool && Array.isArray(tool.functionDeclarations)) {
+      declarations.push(...tool.functionDeclarations);
+    }
+  }
+  return declarations;
+}
+__name(requestFunctionDeclarations, "requestFunctionDeclarations");
+function estimateToolCategories(request, config) {
+  let builtinTools = 0;
+  let mcpTools = 0;
+  let skillTool = 0;
+  const registry = config.getToolRegistry();
+  const declarations = requestFunctionDeclarations(request);
+  if (!declarations) return void 0;
+  for (const declaration of declarations) {
+    const tokens = estimateContextTextTokens(JSON.stringify(declaration));
+    if (declaration.name === ToolNames.SKILL) {
+      skillTool += tokens;
+    } else if (declaration.name && registry.getTool(declaration.name) instanceof DiscoveredMCPTool) {
+      mcpTools += tokens;
+    } else {
+      builtinTools += tokens;
+    }
+  }
+  return { builtinTools, mcpTools, skillTool };
+}
+__name(estimateToolCategories, "estimateToolCategories");
+function extractMemoryTokens(systemInstruction, config) {
+  let remaining = systemInstruction;
+  let memoryTokens = 0;
+  for (const configured of [
+    config.getUserMemory(),
+    config.getAutoMemoryPrompt()
+  ]) {
+    const segment = configured.trim();
+    if (!segment) continue;
+    const index = remaining.indexOf(segment);
+    if (index < 0) continue;
+    remaining = remaining.slice(0, index) + remaining.slice(index + segment.length);
+    memoryTokens += estimateContextTextTokens(segment);
+  }
+  return { systemInstruction: remaining, memoryTokens };
+}
+__name(extractMemoryTokens, "extractMemoryTokens");
+function indexLoadedSkillBodies(outputs) {
+  const tokensByOutput = /* @__PURE__ */ new Map();
+  const outputByHeader = /* @__PURE__ */ new Map();
+  for (const output of outputs) {
+    if (tokensByOutput.has(output)) continue;
+    tokensByOutput.set(output, estimateContextTextTokens(output));
+    const lineEnd = output.indexOf("\n");
+    const header = lineEnd < 0 ? output : output.slice(0, lineEnd);
+    if (!outputByHeader.has(header)) {
+      outputByHeader.set(header, output);
+    } else if (outputByHeader.get(header) !== output) {
+      outputByHeader.set(header, void 0);
+    }
+  }
+  return { tokensByOutput, outputByHeader };
+}
+__name(indexLoadedSkillBodies, "indexLoadedSkillBodies");
+function loadedSkillBodies(config) {
+  const skillTool = config.getToolRegistry().getTool(ToolNames.SKILL);
+  if (!skillTool || !("getLoadedSkillNames" in skillTool) || typeof skillTool.getLoadedSkillNames !== "function") {
+    return indexLoadedSkillBodies([]);
+  }
+  if ("getLoadedSkillContents" in skillTool && typeof skillTool.getLoadedSkillContents === "function") {
+    return indexLoadedSkillBodies(
+      skillTool.getLoadedSkillContents()
+    );
+  }
+  const cachedSkills = config.getSkillManager()?.getCachedSkills();
+  if (!cachedSkills) return indexLoadedSkillBodies([]);
+  const loadedNames = skillTool.getLoadedSkillNames();
+  const outputs = [];
+  for (const skill of cachedSkills) {
+    if (!loadedNames.has(skill.name)) continue;
+    outputs.push(
+      buildSkillLlmContent(path.dirname(skill.filePath), skill.body)
+    );
+  }
+  return indexLoadedSkillBodies(outputs);
+}
+__name(loadedSkillBodies, "loadedSkillBodies");
+function attributeLoadedSkillBodies(contents, indexedBodies) {
+  if (indexedBodies.tokensByOutput.size === 0) {
+    return { contents, skillBodyTokens: 0 };
+  }
+  let skillBodyTokens = 0;
+  let contentsChanged = false;
+  const attributedContents = contents.map((content) => {
+    let partsChanged = false;
+    const parts = content.parts?.map((part) => {
+      const response = part.functionResponse;
+      const output = response?.response?.["output"];
+      if (response?.name !== ToolNames.SKILL || typeof output !== "string") {
+        return part;
+      }
+      let matchedOutput = output;
+      let tokens = indexedBodies.tokensByOutput.get(output);
+      if (tokens === void 0) {
+        const lineEnd = output.indexOf("\n");
+        const header = lineEnd < 0 ? output : output.slice(0, lineEnd);
+        const candidate = indexedBodies.outputByHeader.get(header);
+        if (candidate && output.startsWith(`${candidate}
+`)) {
+          matchedOutput = candidate;
+          tokens = indexedBodies.tokensByOutput.get(candidate);
+        }
+      }
+      if (tokens === void 0) return part;
+      indexedBodies.tokensByOutput.delete(matchedOutput);
+      skillBodyTokens += tokens;
+      partsChanged = true;
+      return {
+        ...part,
+        functionResponse: {
+          ...response,
+          response: {
+            ...response.response,
+            output: output.slice(matchedOutput.length)
+          }
+        }
+      };
+    });
+    if (!partsChanged) return content;
+    contentsChanged = true;
+    return { ...content, parts };
+  });
+  return {
+    contents: contentsChanged ? attributedContents : contents,
+    skillBodyTokens
+  };
+}
+__name(attributeLoadedSkillBodies, "attributeLoadedSkillBodies");
+function createContextUsageSnapshot(request, config, contextWindowSize) {
+  if (!Number.isSafeInteger(contextWindowSize) || contextWindowSize <= 0) {
+    return void 0;
+  }
+  const systemText = getCustomSystemPrompt(request.config?.systemInstruction);
+  const memory = extractMemoryTokens(systemText, config);
+  const tools = estimateToolCategories(request, config);
+  if (!tools) return void 0;
+  const contents = toContents(request.contents);
+  const attributedSkills = attributeLoadedSkillBodies(
+    contents,
+    loadedSkillBodies(config)
+  );
+  const thresholds = computeThresholds(
+    contextWindowSize,
+    config.getAutoCompactThreshold()
+  );
+  const snapshot = {
+    version: 1,
+    window_size_tokens: contextWindowSize,
+    breakdown: {
+      system_prompt_tokens: estimateContextTextTokens(memory.systemInstruction),
+      builtin_tools_tokens: tools.builtinTools,
+      mcp_tools_tokens: tools.mcpTools,
+      memory_files_tokens: memory.memoryTokens,
+      skills_tokens: tools.skillTool + attributedSkills.skillBodyTokens,
+      messages_tokens: estimateContentTokens(attributedSkills.contents)
+    },
+    compaction_reserve_tokens: contextWindowSize - thresholds.auto,
+    estimated: true
+  };
+  return isValidContextUsage(snapshot) ? snapshot : void 0;
+}
+__name(createContextUsageSnapshot, "createContextUsageSnapshot");
+
 // packages/core/src/core/loggingContentGenerator/streamContentDetection.ts
 init_esbuild_shims();
 function hasUserVisibleContent(chunk) {
@@ -287,6 +550,7 @@ var LoggingContentGenerator = class {
   constructor(wrapped, config, generatorConfig) {
     this.wrapped = wrapped;
     this.config = config;
+    this.generatorConfig = generatorConfig;
     this.modalities = generatorConfig.modalities;
     this.splitToolMedia = generatorConfig.splitToolMedia;
     this.toolResultContentFormat = generatorConfig.toolResultContentFormat;
@@ -320,6 +584,21 @@ var LoggingContentGenerator = class {
   getWrapped() {
     return this.wrapped;
   }
+  snapshotContextUsage(request, isInternal) {
+    if (isInternal || !isTelemetrySdkInitialized()) return void 0;
+    try {
+      return createContextUsageSnapshot(
+        request,
+        this.config,
+        this.generatorConfig.contextWindowSize ?? DEFAULT_TOKEN_LIMIT
+      );
+    } catch (error) {
+      debugLogger.warn(
+        `Failed to snapshot context usage: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return void 0;
+    }
+  }
   logApiRequest(contents, model, promptId, sessionId) {
     const requestText = JSON.stringify(contents);
     logApiRequest(
@@ -418,6 +697,8 @@ var LoggingContentGenerator = class {
   }
   async generateContent(req, userPromptId) {
     const retrySnapshot = snapshotRetryMetadata();
+    const isInternal = isInternalPromptId(userPromptId);
+    const contextUsage = this.snapshotContextUsage(req, isInternal);
     const ownerSessionId = this.config.getSessionId();
     const ownerUserId = this.config.getTelemetryUserId();
     const { span: llmSpan, context: llmContext } = startLLMRequestSpanWithContext(req.model, userPromptId, {
@@ -425,10 +706,10 @@ var LoggingContentGenerator = class {
       providerName: this.genAiProviderName,
       outputType: resolveGenAiOutputType(this.generatorAuthType, req.config),
       sessionId: ownerSessionId,
-      userId: ownerUserId
+      userId: ownerUserId,
+      contextUsage
     });
     const requestSessionId = getSessionIdFromContext(llmContext) ?? ownerSessionId;
-    const isInternal = isInternalPromptId(userPromptId);
     const exchange = createGenAiExchange(llmContext, llmSpan, {
       captureContent: !isInternal && this.shouldCollectSensitiveSpanAttributes(),
       sensitiveAttributeMaxLength: this.config.getTelemetrySensitiveSpanAttributeMaxLength()
@@ -551,6 +832,8 @@ var LoggingContentGenerator = class {
   }
   async generateContentStream(req, userPromptId) {
     const retrySnapshot = snapshotRetryMetadata();
+    const isInternal = isInternalPromptId(userPromptId);
+    const contextUsage = this.snapshotContextUsage(req, isInternal);
     const ownerSessionId = this.config.getSessionId();
     const ownerUserId = this.config.getTelemetryUserId();
     const { span: llmSpan, context: llmContext } = startLLMRequestSpanWithContext(req.model, userPromptId, {
@@ -558,14 +841,14 @@ var LoggingContentGenerator = class {
       providerName: this.genAiProviderName,
       outputType: resolveGenAiOutputType(this.generatorAuthType, req.config),
       sessionId: ownerSessionId,
-      userId: ownerUserId
+      userId: ownerUserId,
+      contextUsage
     });
     const requestSessionId = getSessionIdFromContext(llmContext) ?? ownerSessionId;
     try {
       llmSpan.setAttribute("gen_ai.request.stream", true);
     } catch {
     }
-    const isInternal = isInternalPromptId(userPromptId);
     const exchange = createGenAiExchange(llmContext, llmSpan, {
       captureContent: !isInternal && this.shouldCollectSensitiveSpanAttributes(),
       sensitiveAttributeMaxLength: this.config.getTelemetrySensitiveSpanAttributeMaxLength()
@@ -786,7 +1069,7 @@ var LoggingContentGenerator = class {
       if (lastResponseForLogging && responses.at(-1) !== lastResponseForLogging) {
         responses.push(lastResponseForLogging);
       }
-      const consolidatedResponse = shouldCollectResponses ? this.consolidateGeminiResponsesForLogging(responses) : void 0;
+      const consolidatedResponse = shouldCollectResponses ? this.consolidateLlmResponsesForLogging(responses) : void 0;
       if (consolidatedResponse) {
         consolidatedResponse.usageMetadata = lastUsageMetadata;
       }
@@ -872,7 +1155,7 @@ var LoggingContentGenerator = class {
       return void 0;
     }
     const requestContext = this.createLoggingRequestContext(request.model);
-    const messages = OpenAIContentConverter.convertGeminiRequestToOpenAI(
+    const messages = OpenAIContentConverter.convertLlmRequestToOpenAI(
       request,
       requestContext,
       {
@@ -884,7 +1167,7 @@ var LoggingContentGenerator = class {
       messages
     };
     if (request.config?.tools) {
-      openaiRequest.tools = await OpenAIContentConverter.convertGeminiToolsToOpenAI(
+      openaiRequest.tools = await OpenAIContentConverter.convertLlmToolsToOpenAI(
         request.config.tools,
         this.schemaCompliance ?? "auto"
       );
@@ -922,7 +1205,7 @@ var LoggingContentGenerator = class {
     if (!this.openaiLogger || !openaiRequest) {
       return;
     }
-    const openaiResponse = response ? this.convertGeminiResponseToOpenAIForLogging(response, openaiRequest) : void 0;
+    const openaiResponse = response ? this.convertLlmResponseToOpenAIForLogging(response, openaiRequest) : void 0;
     await this.openaiLogger.logInteraction(
       openaiRequest,
       openaiResponse,
@@ -937,13 +1220,13 @@ var LoggingContentGenerator = class {
       debugLogger.warn("Failed to log OpenAI interaction:", loggingError);
     }
   }
-  convertGeminiResponseToOpenAIForLogging(response, openaiRequest) {
-    return OpenAIContentConverter.convertGeminiResponseToOpenAI(
+  convertLlmResponseToOpenAIForLogging(response, openaiRequest) {
+    return OpenAIContentConverter.convertLlmResponseToOpenAI(
       response,
       this.createLoggingRequestContext(openaiRequest.model)
     );
   }
-  consolidateGeminiResponsesForLogging(responses) {
+  consolidateLlmResponsesForLogging(responses) {
     if (responses.length === 0) {
       return void 0;
     }

package/chunks/{loop-wakeup-XJFONSQ7.js → loop-wakeup-EBM4F5MZ.js}

@@ -4,24 +4,24 @@ import {
   WAKEUP_MAX_SECONDS,
   WAKEUP_MIN_SECONDS,
   clampWakeupSeconds
-} from "./chunk-EKSCLBBF.js";
+} from "./chunk-SMJYTKTB.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-D5LUXLUH.js";
+import "./chunk-UJ4DUYIH.js";
 import {
   todoWorkChainContext
 } from "./chunk-O6GEWCJA.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-23RFD54N.js";
+import "./chunk-KHP66DFN.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   getErrorMessage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{ls-3VAT2J7A.js → ls-F6TRX3DD.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   getMemoryBaseDir
-} from "./chunk-6PJOTWAN.js";
+} from "./chunk-HT5S5TRQ.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS
-} from "./chunk-PDQGMSZK.js";
+} from "./chunk-ODZF64DM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   Storage,
   createDebugLogger,
@@ -20,7 +20,7 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{lsp-5W7IRUBH.js → lsp-QYTOS2FI.js}

@@ -5,10 +5,10 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   unescapePath
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims