@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/{chunk-RWTEFFPU.js → chunk-ML52PL6O.js}

@@ -45,8 +45,11 @@ function sanitizeLogText(text, maxLen) {
 }
 __name(sanitizeLogText, "sanitizeLogText");
 
-// packages/channels/base/dist/index.js
+// packages/channels/base/dist/PairingStore.js
 init_esbuild_shims();
+import * as crypto2 from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 
 // packages/channels/base/dist/paths.js
 init_esbuild_shims();
@@ -89,6 +92,202 @@ function getWorkspaceScopeDirName(workspaceCwd) {
 }
 __name(getWorkspaceScopeDirName, "getWorkspaceScopeDirName");
 
+// packages/channels/base/dist/PairingStore.js
+var SAFE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var CODE_LENGTH = 8;
+var EXPIRY_MS = 60 * 60 * 1e3;
+var MAX_PENDING = 3;
+var PairingStore = class {
+  static {
+    __name(this, "PairingStore");
+  }
+  dir;
+  pendingPath;
+  allowlistPath;
+  migratedSentinelPath;
+  /**
+   * @param channelName Channel name the state is keyed by.
+   * @param workspaceCwd Workspace working directory to scope the state to.
+   *   When provided, files live under
+   *   `<qwen-home>/channels/<workspace-scope>/` so two workspaces using the
+   *   same channel name never share pairing requests or allowlist entries
+   *   (see #7017 — sharing them is an authorization-boundary violation in
+   *   multi-workspace daemon deployments). Omitting it preserves the legacy
+   *   global layout (`<qwen-home>/channels/`).
+   */
+  constructor(channelName, workspaceCwd) {
+    const channelsRoot = path2.join(getGlobalQwenDir(), "channels");
+    this.dir = workspaceCwd ? path2.join(channelsRoot, getWorkspaceScopeDirName(workspaceCwd)) : channelsRoot;
+    const safeChannelName = encodeURIComponent(channelName);
+    this.pendingPath = path2.join(this.dir, `${safeChannelName}-pairing.json`);
+    this.allowlistPath = path2.join(this.dir, `${safeChannelName}-allowlist.json`);
+    this.migratedSentinelPath = path2.join(this.dir, `${safeChannelName}.migrated`);
+    if (workspaceCwd) {
+      this.migrateLegacyState(channelsRoot, channelName);
+    }
+  }
+  /**
+   * One-time grandfathering of pre-scoping state: the first time this
+   * (workspace, channel) pair is constructed, copy the legacy GLOBAL files in
+   * so senders that were already approved stay approved after upgrading.
+   *
+   * Gated by a per-channel sentinel file inside the scope directory — NOT by
+   * the directory itself: one workspace can start several channels in turn,
+   * and a directory-level gate would let only the first channel ever migrate.
+   * The sentinel is written even when there was nothing to copy, so a legacy
+   * file written later (e.g. by an older version still running concurrently)
+   * is never absorbed into a scope that already went through this decision.
+   *
+   * Each file is copied independently and best-effort (an unreadable pairing
+   * file must not block the allowlist, and vice versa), via a
+   * uniquely-named temp file + atomic rename so a crash mid-copy cannot
+   * leave a truncated scoped file behind the closed gate. A file the scoped
+   * store already has is never overwritten.
+   *
+   * Copy, not move: another workspace upgrading later must be able to
+   * grandfather the same baseline, and an older qwen version running
+   * concurrently still reads the global files.
+   *
+   * Revocation therefore means REMOVING ENTRIES from the scoped allowlist
+   * (and from the legacy global file, while it exists) — not deleting files.
+   */
+  migrateLegacyState(channelsRoot, channelName) {
+    try {
+      if (fs2.existsSync(this.migratedSentinelPath)) {
+        return;
+      }
+      const legacyPairs = [
+        [
+          path2.join(channelsRoot, `${channelName}-pairing.json`),
+          this.pendingPath
+        ],
+        [
+          path2.join(channelsRoot, `${channelName}-allowlist.json`),
+          this.allowlistPath
+        ]
+      ];
+      this.ensureDir();
+      let allSucceeded = true;
+      for (const [legacyPath, scopedPath] of legacyPairs) {
+        try {
+          if (path2.dirname(path2.resolve(legacyPath)) !== channelsRoot) {
+            continue;
+          }
+          if (fs2.existsSync(scopedPath) || !fs2.existsSync(legacyPath)) {
+            continue;
+          }
+          const tmpPath = `${scopedPath}.${process.pid}.migrating`;
+          fs2.copyFileSync(legacyPath, tmpPath);
+          fs2.renameSync(tmpPath, scopedPath);
+        } catch (err) {
+          allSucceeded = false;
+          process.stderr.write(`[PairingStore] legacy migration of ${path2.basename(legacyPath)} failed for channel "${channelName}": ${err?.message}; will retry on next start
+`);
+        }
+      }
+      if (allSucceeded) {
+        fs2.writeFileSync(this.migratedSentinelPath, "");
+      }
+    } catch (err) {
+      process.stderr.write(`[PairingStore] legacy migration failed for channel "${channelName}": ${err?.message}; scoped store starts empty
+`);
+    }
+  }
+  isApproved(senderId) {
+    const list = this.readAllowlist();
+    return list.includes(senderId);
+  }
+  /**
+   * Create a pairing request for an unknown sender.
+   * Returns the code if created, or null if the pending cap is reached.
+   * If the sender already has a non-expired pending request, returns that code.
+   */
+  createRequest(senderId, senderName) {
+    const pending = this.readPending();
+    const now = Date.now();
+    const active = pending.filter((r) => now - r.createdAt < EXPIRY_MS);
+    const existing = active.find((r) => r.senderId === senderId);
+    if (existing) {
+      return existing.code;
+    }
+    if (active.length >= MAX_PENDING) {
+      return null;
+    }
+    const code = generateCode();
+    active.push({ senderId, senderName, code, createdAt: now });
+    this.writePending(active);
+    return code;
+  }
+  /**
+   * Approve a pairing request by code.
+   * Returns the sender ID if found, or null if not found / expired.
+   */
+  approve(code) {
+    const pending = this.readPending();
+    const now = Date.now();
+    const idx = pending.findIndex((r) => r.code === code.toUpperCase() && now - r.createdAt < EXPIRY_MS);
+    if (idx === -1)
+      return null;
+    const request = pending[idx];
+    pending.splice(idx, 1);
+    this.writePending(pending);
+    const list = this.readAllowlist();
+    if (!list.includes(request.senderId)) {
+      list.push(request.senderId);
+      this.writeAllowlist(list);
+    }
+    return request;
+  }
+  listPending() {
+    const pending = this.readPending();
+    const now = Date.now();
+    return pending.filter((r) => now - r.createdAt < EXPIRY_MS);
+  }
+  getAllowlist() {
+    return this.readAllowlist();
+  }
+  ensureDir() {
+    if (!fs2.existsSync(this.dir)) {
+      fs2.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  readPending() {
+    try {
+      const data = fs2.readFileSync(this.pendingPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  writePending(requests) {
+    this.ensureDir();
+    fs2.writeFileSync(this.pendingPath, JSON.stringify(requests, null, 2));
+  }
+  readAllowlist() {
+    try {
+      const data = fs2.readFileSync(this.allowlistPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  writeAllowlist(list) {
+    this.ensureDir();
+    fs2.writeFileSync(this.allowlistPath, JSON.stringify(list, null, 2));
+  }
+};
+function generateCode() {
+  let code = "";
+  for (let i = 0; i < CODE_LENGTH; i++) {
+    code += SAFE_ALPHABET[crypto2.randomInt(SAFE_ALPHABET.length)];
+  }
+  return code;
+}
+__name(generateCode, "generateCode");
+
+// packages/channels/base/dist/index.js
+init_esbuild_shims();
+
 // packages/channels/base/dist/AcpBridge.js
 init_esbuild_shims();
 import { spawn } from "node:child_process";
@@ -1515,8 +1714,8 @@ var DmGate = class {
 
 // packages/channels/base/dist/group-history-store.js
 init_esbuild_shims();
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { appendFileSync, chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 var DEFAULT_MAX_KEYS = 1e3;
 var DEFAULT_COMPACT_AFTER_RECORDS = 1e3;
 var GroupHistoryStore = class {
@@ -1628,12 +1827,12 @@ var GroupHistoryStore = class {
     };
   }
   readRecords() {
-    if (!existsSync(this.filePath)) {
+    if (!existsSync2(this.filePath)) {
       return { records: [], hadInvalidRecords: false };
     }
     let data;
     try {
-      data = readFileSync(this.filePath, "utf-8");
+      data = readFileSync2(this.filePath, "utf-8");
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) {
         return { records: [], hadInvalidRecords: false };
@@ -1660,8 +1859,8 @@ var GroupHistoryStore = class {
     return { records, hadInvalidRecords };
   }
   append(record) {
-    const dir = dirname(this.filePath);
-    mkdirSync(dir, { recursive: true, mode: 448 });
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
     chmodPrivate(dir, 448);
     appendFileSync(this.filePath, `${JSON.stringify(record)}
 `, {
@@ -1671,8 +1870,8 @@ var GroupHistoryStore = class {
     chmodPrivate(this.filePath, 384);
   }
   compact(state, limits) {
-    const dir = dirname(this.filePath);
-    mkdirSync(dir, { recursive: true, mode: 448 });
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
     chmodPrivate(dir, 448);
     const records = [];
     const recordedAt = Date.now();
@@ -1689,10 +1888,10 @@ var GroupHistoryStore = class {
     }
     const data = records.length > 0 ? `${records.map((record) => JSON.stringify(record)).join("\n")}
 ` : "";
-    const tempPath = join2(dir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
-    writeFileSync(tempPath, data, { encoding: "utf-8", mode: 384 });
+    const tempPath = join3(dir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
+    writeFileSync2(tempPath, data, { encoding: "utf-8", mode: 384 });
     chmodPrivate(tempPath, 384);
-    renameSync(tempPath, this.filePath);
+    renameSync2(tempPath, this.filePath);
     chmodPrivate(this.filePath, 384);
   }
 };
@@ -1798,203 +1997,6 @@ var SenderGate = class {
   }
 };
 
-// packages/channels/base/dist/PairingStore.js
-init_esbuild_shims();
-import * as crypto2 from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-var SAFE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-var CODE_LENGTH = 8;
-var EXPIRY_MS = 60 * 60 * 1e3;
-var MAX_PENDING = 3;
-var PairingStore = class {
-  static {
-    __name(this, "PairingStore");
-  }
-  dir;
-  pendingPath;
-  allowlistPath;
-  migratedSentinelPath;
-  /**
-   * @param channelName Channel name the state is keyed by.
-   * @param workspaceCwd Workspace working directory to scope the state to.
-   *   When provided, files live under
-   *   `<qwen-home>/channels/<workspace-scope>/` so two workspaces using the
-   *   same channel name never share pairing requests or allowlist entries
-   *   (see #7017 — sharing them is an authorization-boundary violation in
-   *   multi-workspace daemon deployments). Omitting it preserves the legacy
-   *   global layout (`<qwen-home>/channels/`).
-   */
-  constructor(channelName, workspaceCwd) {
-    const channelsRoot = path2.join(getGlobalQwenDir(), "channels");
-    this.dir = workspaceCwd ? path2.join(channelsRoot, getWorkspaceScopeDirName(workspaceCwd)) : channelsRoot;
-    const safeChannelName = encodeURIComponent(channelName);
-    this.pendingPath = path2.join(this.dir, `${safeChannelName}-pairing.json`);
-    this.allowlistPath = path2.join(this.dir, `${safeChannelName}-allowlist.json`);
-    this.migratedSentinelPath = path2.join(this.dir, `${safeChannelName}.migrated`);
-    if (workspaceCwd) {
-      this.migrateLegacyState(channelsRoot, channelName);
-    }
-  }
-  /**
-   * One-time grandfathering of pre-scoping state: the first time this
-   * (workspace, channel) pair is constructed, copy the legacy GLOBAL files in
-   * so senders that were already approved stay approved after upgrading.
-   *
-   * Gated by a per-channel sentinel file inside the scope directory — NOT by
-   * the directory itself: one workspace can start several channels in turn,
-   * and a directory-level gate would let only the first channel ever migrate.
-   * The sentinel is written even when there was nothing to copy, so a legacy
-   * file written later (e.g. by an older version still running concurrently)
-   * is never absorbed into a scope that already went through this decision.
-   *
-   * Each file is copied independently and best-effort (an unreadable pairing
-   * file must not block the allowlist, and vice versa), via a
-   * uniquely-named temp file + atomic rename so a crash mid-copy cannot
-   * leave a truncated scoped file behind the closed gate. A file the scoped
-   * store already has is never overwritten.
-   *
-   * Copy, not move: another workspace upgrading later must be able to
-   * grandfather the same baseline, and an older qwen version running
-   * concurrently still reads the global files.
-   *
-   * Revocation therefore means REMOVING ENTRIES from the scoped allowlist
-   * (and from the legacy global file, while it exists) — not deleting files.
-   */
-  migrateLegacyState(channelsRoot, channelName) {
-    try {
-      if (fs2.existsSync(this.migratedSentinelPath)) {
-        return;
-      }
-      const legacyPairs = [
-        [
-          path2.join(channelsRoot, `${channelName}-pairing.json`),
-          this.pendingPath
-        ],
-        [
-          path2.join(channelsRoot, `${channelName}-allowlist.json`),
-          this.allowlistPath
-        ]
-      ];
-      this.ensureDir();
-      let allSucceeded = true;
-      for (const [legacyPath, scopedPath] of legacyPairs) {
-        try {
-          if (path2.dirname(path2.resolve(legacyPath)) !== channelsRoot) {
-            continue;
-          }
-          if (fs2.existsSync(scopedPath) || !fs2.existsSync(legacyPath)) {
-            continue;
-          }
-          const tmpPath = `${scopedPath}.${process.pid}.migrating`;
-          fs2.copyFileSync(legacyPath, tmpPath);
-          fs2.renameSync(tmpPath, scopedPath);
-        } catch (err) {
-          allSucceeded = false;
-          process.stderr.write(`[PairingStore] legacy migration of ${path2.basename(legacyPath)} failed for channel "${channelName}": ${err?.message}; will retry on next start
-`);
-        }
-      }
-      if (allSucceeded) {
-        fs2.writeFileSync(this.migratedSentinelPath, "");
-      }
-    } catch (err) {
-      process.stderr.write(`[PairingStore] legacy migration failed for channel "${channelName}": ${err?.message}; scoped store starts empty
-`);
-    }
-  }
-  isApproved(senderId) {
-    const list = this.readAllowlist();
-    return list.includes(senderId);
-  }
-  /**
-   * Create a pairing request for an unknown sender.
-   * Returns the code if created, or null if the pending cap is reached.
-   * If the sender already has a non-expired pending request, returns that code.
-   */
-  createRequest(senderId, senderName) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const active = pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-    const existing = active.find((r) => r.senderId === senderId);
-    if (existing) {
-      return existing.code;
-    }
-    if (active.length >= MAX_PENDING) {
-      return null;
-    }
-    const code = generateCode();
-    active.push({ senderId, senderName, code, createdAt: now });
-    this.writePending(active);
-    return code;
-  }
-  /**
-   * Approve a pairing request by code.
-   * Returns the sender ID if found, or null if not found / expired.
-   */
-  approve(code) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const idx = pending.findIndex((r) => r.code === code.toUpperCase() && now - r.createdAt < EXPIRY_MS);
-    if (idx === -1)
-      return null;
-    const request = pending[idx];
-    pending.splice(idx, 1);
-    this.writePending(pending);
-    const list = this.readAllowlist();
-    if (!list.includes(request.senderId)) {
-      list.push(request.senderId);
-      this.writeAllowlist(list);
-    }
-    return request;
-  }
-  listPending() {
-    const pending = this.readPending();
-    const now = Date.now();
-    return pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-  }
-  getAllowlist() {
-    return this.readAllowlist();
-  }
-  ensureDir() {
-    if (!fs2.existsSync(this.dir)) {
-      fs2.mkdirSync(this.dir, { recursive: true });
-    }
-  }
-  readPending() {
-    try {
-      const data = fs2.readFileSync(this.pendingPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writePending(requests) {
-    this.ensureDir();
-    fs2.writeFileSync(this.pendingPath, JSON.stringify(requests, null, 2));
-  }
-  readAllowlist() {
-    try {
-      const data = fs2.readFileSync(this.allowlistPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writeAllowlist(list) {
-    this.ensureDir();
-    fs2.writeFileSync(this.allowlistPath, JSON.stringify(list, null, 2));
-  }
-};
-function generateCode() {
-  let code = "";
-  for (let i = 0; i < CODE_LENGTH; i++) {
-    code += SAFE_ALPHABET[crypto2.randomInt(SAFE_ALPHABET.length)];
-  }
-  return code;
-}
-__name(generateCode, "generateCode");
-
 // packages/channels/base/dist/SessionRouter.js
 init_esbuild_shims();
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, rmSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";

package/chunks/{chunk-RF3EXIHJ.js → chunk-MSLKI6C2.js}

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-YPE6A4GC.js";
+} from "./chunk-B7QDM6Z7.js";
 import {
   handleAtCommand
-} from "./chunk-VULLI6WQ.js";
+} from "./chunk-GDIPH4JY.js";
 import {
   JsonOutputAdapter
-} from "./chunk-3RN6GBKS.js";
+} from "./chunk-QPDRAXDJ.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-BKHWX6I2.js";
+} from "./chunk-P5V4T7NK.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,11 +24,11 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-LB6DUZ26.js";
+} from "./chunk-M4UKFCZ2.js";
 import {
   RunBudgetEnforcer,
   cleanupReviewWorktreeLeases
-} from "./chunk-TPRQ7RZH.js";
+} from "./chunk-BYFNTGKI.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -36,10 +36,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-IKYJHJNF.js";
+} from "./chunk-VFSJ5VRH.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-KMQ33DO4.js";
+} from "./chunk-LG4GZIVV.js";
 import {
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   buildSessionRecoveryPlanFromApiHistory,
@@ -57,7 +57,7 @@ import {
   partitionByConcurrencySafety,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -66,11 +66,11 @@ import {
 } from "./chunk-L26JL52R.js";
 import {
   uiTelemetryService
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry
-} from "./chunk-MB4MZHMJ.js";
+} from "./chunk-SRZ6DXVG.js";
 import {
   ToolNames
 } from "./chunk-PR75REBZ.js";
@@ -80,7 +80,7 @@ import {
 } from "./chunk-NL7LTRLR.js";
 import {
   registerCleanup
-} from "./chunk-PWVFN2LF.js";
+} from "./chunk-B4UMZKMU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-X5XDDSSH.js → chunk-MVS3NS2N.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ML52PL6O.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-5NBDS5S6.js → chunk-N3FAY5CM.js}

@@ -18,21 +18,23 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
-  createWorkerDiagnosticRedactor,
   isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
-  isChannelWebhookTaskResultMessage,
+  isChannelWebhookTaskResultMessage
+} from "./chunk-U4VTUMMK.js";
+import {
+  createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-LK7CHLVP.js";
+} from "./chunk-HV3G62R6.js";
 import {
   channelSelectionNames
-} from "./chunk-JLU636DO.js";
+} from "./chunk-ALMR3E6Q.js";
 import {
   sanitizeLogText
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ML52PL6O.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,

package/chunks/{chunk-55DJUCI2.js → chunk-OJGCZBB7.js}

@@ -34,12 +34,14 @@ import {
   runtimeDiagnostics
 } from "./chunk-LS77BEZP.js";
 import {
-  reportOpenAiRequest
-} from "./chunk-LEH5C7FV.js";
+  reportOpenAiChunk,
+  reportOpenAiRequest,
+  reportOpenAiResponse
+} from "./chunk-FY3M44RD.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import {
   reconcileMaxTokens
 } from "./chunk-UW5EOVUN.js";
@@ -1074,7 +1076,7 @@ var ContentGenerationPipeline = class {
       request,
       userPromptId,
       false,
-      async (openaiRequest, context) => {
+      async (openaiRequest, context, telemetryAttempt) => {
         const parentSignal = request.config?.abortSignal;
         const perRequestAc = parentSignal ? createChildAbortController(parentSignal) : void 0;
         try {
@@ -1084,6 +1086,7 @@ var ContentGenerationPipeline = class {
               signal: perRequestAc?.signal
             }
           );
+          reportOpenAiResponse(telemetryAttempt, openaiResponse);
           const geminiResponse = OpenAIContentConverter.convertOpenAIResponseToGemini(
             openaiResponse,
             context
@@ -1100,7 +1103,7 @@ var ContentGenerationPipeline = class {
       request,
       userPromptId,
       true,
-      async (openaiRequest, context) => {
+      async (openaiRequest, context, telemetryAttempt) => {
         const parentSignal = request.config?.abortSignal;
         const perRequestAc = createChildAbortController(parentSignal);
         let stream;
@@ -1155,7 +1158,8 @@ var ContentGenerationPipeline = class {
           guarded,
           context,
           request,
-          userPromptId
+          userPromptId,
+          telemetryAttempt
         );
         async function* drainThenCleanup() {
           try {
@@ -1177,7 +1181,7 @@ var ContentGenerationPipeline = class {
    * 3. Handle chunk merging for providers that send finishReason and usageMetadata separately
    * 4. Handle success/error logging
    */
-  async *processStreamWithLogging(stream, context, request, userPromptId) {
+  async *processStreamWithLogging(stream, context, request, userPromptId, telemetryAttempt) {
     let pendingFinishResponse = null;
     let finishYielded = false;
     let pendingFinishProtocolTagSanitized;
@@ -1201,6 +1205,7 @@ var ContentGenerationPipeline = class {
     }, "logPendingProtocolTagSanitized");
     try {
       for await (const chunk of stream) {
+        reportOpenAiChunk(telemetryAttempt, chunk);
         if (chunk.choices?.[0]?.finish_reason === "error_finish") {
           const errorContent = chunk.choices?.[0]?.delta?.content?.trim() || "Unknown stream error";
           throw new StreamContentError(errorContent);
@@ -1513,8 +1518,8 @@ var ContentGenerationPipeline = class {
       );
       openaiRequestCaptureContext.getStore()?.(openaiRequest);
       runtimeDiagnostics.recordOpenAIWireRequest(openaiRequest);
-      reportOpenAiRequest(openaiRequest);
-      return executor(openaiRequest, context);
+      const telemetryAttempt = reportOpenAiRequest(openaiRequest);
+      return executor(openaiRequest, context, telemetryAttempt);
     }, "executeAttempt");
     try {
       return await executeAttempt();

package/chunks/{chunk-BKHWX6I2.js → chunk-P5V4T7NK.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-LB6DUZ26.js";
+} from "./chunk-M4UKFCZ2.js";
 import {
   parseAndFormatApiError
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";