@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/{chunk-TWVE5ZS5.js → chunk-VULLI6WQ.js}

@@ -2,11 +2,13 @@
 "use strict";
 import {
   t
-} from "./chunk-VRRF3GW5.js";
+} from "./chunk-LKEJ26GS.js";
 import {
+  SessionReferenceService,
+  SessionService,
   readManyFiles,
   stripTerminalControlSequences
-} from "./chunk-OTQ6PSZC.js";
+} from "./chunk-PHOF65IG.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -14,14 +16,14 @@ import {
 } from "./chunk-HTO4JFDZ.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-ZDP2Y2AL.js";
+} from "./chunk-CIKQ7KKO.js";
 import {
   Storage,
   getErrorMessage,
   isNodeError,
   isSubpath,
   unescapePath
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -212,11 +214,32 @@ function getExtensionSuggestions(config, pattern) {
     value: buildExtensionRef(ext.name),
     description: ext.config.description ? sanitizeDisplayText(ext.config.description) ?? void 0 : void 0,
     sourceBadge: t("Extension"),
-    isDirectory: false
+    isDirectory: false,
+    category: "extension"
   }));
 }
 __name(getExtensionSuggestions, "getExtensionSuggestions");
 
+// packages/cli/src/ui/hooks/session-mention-ref.ts
+init_esbuild_shims();
+var SESSION_MENTION_PREFIX = "session:";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isSessionId(value) {
+  return UUID_RE.test(value.trim());
+}
+__name(isSessionId, "isSessionId");
+function parseSessionRef(pathName) {
+  if (!pathName.startsWith(SESSION_MENTION_PREFIX)) return null;
+  const remainder = pathName.slice(SESSION_MENTION_PREFIX.length).trim();
+  if (remainder.length === 0) return null;
+  return isSessionId(remainder) ? { id: remainder } : { title: remainder };
+}
+__name(parseSessionRef, "parseSessionRef");
+function buildSessionRef(idOrTitle) {
+  return `${SESSION_MENTION_PREFIX}${idOrTitle}`;
+}
+__name(buildSessionRef, "buildSessionRef");
+
 // packages/cli/src/utils/mcp-server-mention.ts
 init_esbuild_shims();
 var MCP_SERVER_REF_PREFIX = "mcp:";
@@ -358,6 +381,7 @@ async function resolveAtCommandQuery({
   const mcpServerMentions = [];
   const activeExtensions = config.getActiveExtensions?.() ?? [];
   const extensionMentions = [];
+  const sessionMentions = [];
   for (const atPathPart of atPathCommandParts) {
     const originalAtPath = atPathPart.content;
     if (originalAtPath === "@") {
@@ -382,6 +406,16 @@ async function resolveAtCommandQuery({
       );
       continue;
     }
+    const sessionRef = parseSessionRef(pathName);
+    if (sessionRef) {
+      if (!sessionMentions.some(
+        (m) => (m.ref.id ?? m.ref.title) === (sessionRef.id ?? sessionRef.title)
+      )) {
+        sessionMentions.push({ originalAtPath, ref: sessionRef });
+      }
+      atPathToResolvedSpecMap.set(originalAtPath, pathName);
+      continue;
+    }
     const resourceRef = parseMcpResourceRef(pathName, mcpServerNames);
     if (resourceRef) {
       mcpResourceRefs.push({ originalAtPath, ...resourceRef });
@@ -556,7 +590,7 @@ ${messages.join("\n")}`;
       confirmationDetails: void 0
     });
   }
-  if (pathSpecsToRead.length === 0 && mcpResourceRefs.length === 0 && mcpServerMentions.length === 0 && extensionMentions.length === 0) {
+  if (pathSpecsToRead.length === 0 && mcpResourceRefs.length === 0 && mcpServerMentions.length === 0 && extensionMentions.length === 0 && sessionMentions.length === 0) {
     onDebugMessage("No valid file paths found in @ commands to read.");
     if (initialQueryText === "@" && query.trim() === "@") {
       return { processedQuery: [{ text: query }], shouldProceed: true };
@@ -610,6 +644,136 @@ ${messages.join("\n")}`;
       }
     });
   }
+  const resolvedSessionIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < sessionMentions.length; i++) {
+    const { originalAtPath, ref } = sessionMentions[i];
+    const callId = `client-session-${userMessageTimestamp}-${i}`;
+    let sessionId = ref.id;
+    if (!sessionId && ref.title) {
+      let matches = [];
+      try {
+        matches = await new SessionService(
+          config.getProjectRoot()
+        ).findSessionsByTitle(ref.title);
+      } catch (error) {
+        const reason = `Could not look up sessions matching "@${originalAtPath.substring(1)}" (${getErrorMessage(error)}); try a session id instead.`;
+        onDebugMessage(reason);
+        scopedMentionEntries.push({
+          originalAtPath,
+          part: { text: "" },
+          label: buildSessionRef(ref.title ?? originalAtPath),
+          display: {
+            callId,
+            name: "Referenced Session",
+            description: `Reference session "${ref.title ?? ""}"`,
+            status: "Error" /* Error */,
+            resultDisplay: reason,
+            confirmationDetails: void 0
+          }
+        });
+        continue;
+      }
+      if (matches.length === 1) {
+        sessionId = matches[0].sessionId;
+      } else {
+        const reason = matches.length === 0 ? `No session matches "@${originalAtPath.substring(1)}".` : `"@${originalAtPath.substring(1)}" is ambiguous (${matches.length} matches); use the picker or a session id.`;
+        onDebugMessage(reason);
+        scopedMentionEntries.push({
+          originalAtPath,
+          part: { text: "" },
+          label: buildSessionRef(ref.title),
+          display: {
+            callId,
+            name: "Referenced Session",
+            description: `Reference session "${ref.title}"`,
+            status: "Error" /* Error */,
+            resultDisplay: reason,
+            confirmationDetails: void 0
+          }
+        });
+        continue;
+      }
+    }
+    if (!sessionId) {
+      const reason = `Session reference "@${originalAtPath.substring(1)}" could not be resolved.`;
+      onDebugMessage(reason);
+      scopedMentionEntries.push({
+        originalAtPath,
+        part: { text: "" },
+        label: buildSessionRef(ref.title ?? ref.id ?? originalAtPath),
+        display: {
+          callId,
+          name: "Referenced Session",
+          description: `Reference session "${ref.title ?? ref.id ?? ""}"`,
+          status: "Error" /* Error */,
+          resultDisplay: reason,
+          confirmationDetails: void 0
+        }
+      });
+      continue;
+    }
+    if (resolvedSessionIds.has(sessionId)) {
+      onDebugMessage(
+        `Session reference "@${originalAtPath.substring(1)}" resolves to session ${sessionId}, which was already referenced; skipping duplicate.`
+      );
+      continue;
+    }
+    resolvedSessionIds.add(sessionId);
+    let resolved;
+    try {
+      resolved = await new SessionReferenceService(
+        config.getProjectRoot()
+      ).resolve(sessionId, ref.title ? { title: ref.title } : {});
+    } catch (error) {
+      const reason = `Failed to load session "${sessionId}" (${getErrorMessage(error)}); the transcript may be corrupted or unreadable.`;
+      onDebugMessage(reason);
+      scopedMentionEntries.push({
+        originalAtPath,
+        part: { text: "" },
+        label: buildSessionRef(sessionId),
+        display: {
+          callId,
+          name: "Referenced Session",
+          description: `Reference session ${sessionId}`,
+          status: "Error" /* Error */,
+          resultDisplay: reason,
+          confirmationDetails: void 0
+        }
+      });
+      continue;
+    }
+    if ("notFound" in resolved) {
+      const reason = `Session "${sessionId}" not found in this project.`;
+      onDebugMessage(reason);
+      scopedMentionEntries.push({
+        originalAtPath,
+        part: { text: "" },
+        label: buildSessionRef(sessionId),
+        display: {
+          callId,
+          name: "Referenced Session",
+          description: `Reference session ${sessionId}`,
+          status: "Error" /* Error */,
+          resultDisplay: reason,
+          confirmationDetails: void 0
+        }
+      });
+      continue;
+    }
+    scopedMentionEntries.push({
+      originalAtPath,
+      part: { text: resolved.text },
+      label: buildSessionRef(sessionId),
+      display: {
+        callId,
+        name: "Referenced Session",
+        description: `Referenced session "${resolved.meta.title}"${resolved.truncated ? " (truncated)" : ""}`,
+        status: "Success" /* Success */,
+        resultDisplay: void 0,
+        confirmationDetails: void 0
+      }
+    });
+  }
   const scopedMentionOrder = new Map(
     atPathCommandParts.map((part, index) => [part.content, index])
   );
@@ -742,6 +906,8 @@ export {
   sanitizeDisplayText,
   buildExtensionMentionContext,
   getExtensionSuggestions,
+  SESSION_MENTION_PREFIX,
+  buildSessionRef,
   parseMcpServerRef,
   buildMcpServerRef,
   matchMcpServerByRef,

package/chunks/{chunk-LNDD3IML.js → chunk-WCXCRJYB.js}

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

package/chunks/{chunk-2LI23QA6.js → chunk-X5XDDSSH.js}

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

package/chunks/{chunk-Q35QUZDQ.js → chunk-Y34KJKDC.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-5NJTNQUW.js";
+} from "./chunk-PWVFN2LF.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7NR2AIK6.js → chunk-YBL3QUDD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-VRRF3GW5.js";
+} from "./chunk-LKEJ26GS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -27,7 +27,7 @@ function resolveVoiceTransport(model) {
 }
 __name(resolveVoiceTransport, "resolveVoiceTransport");
 function isTranscribableVoiceModel(model) {
-  return model.authType === "openai" /* USE_OPENAI */ && model.isRuntimeModel !== true && typeof model.baseUrl === "string" && model.baseUrl.trim().length > 0;
+  return model.authType === "openai" /* USE_OPENAI */ && model.isRuntimeModel !== true && model.imageOnly !== true && typeof model.baseUrl === "string" && model.baseUrl.trim().length > 0;
 }
 __name(isTranscribableVoiceModel, "isTranscribableVoiceModel");
 function isSelectableVoiceModel(model) {

package/chunks/{chunk-H4AR2JQF.js → chunk-YH6G52F2.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-GPSKDNEE.js";
+} from "./chunk-K4XWPEWB.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-WHGVTP7Q.js";
+} from "./chunk-L26JL52R.js";
 import {
   resolveActiveTeamName
 } from "./chunk-6AM5D4ME.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-YM3SZTH4.js";
+} from "./chunk-PR75REBZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-MBOJHHPI.js → chunk-YPE6A4GC.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   t
-} from "./chunk-VRRF3GW5.js";
+} from "./chunk-LKEJ26GS.js";
 import {
   writeStderrLine
 } from "./chunk-OWAK7LMW.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3EK5ZOUQ.js → chunk-YX324OPW.js}

@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.20.2-headless-image-routing.1";
+  return "0.21.0";
 }
 __name(getCliVersion, "getCliVersion");
 

package/chunks/{chunk-4PTLZ3NX.js → chunk-Z2BC6UJ5.js}

@@ -13,15 +13,15 @@ import {
 } from "./chunk-OWAK7LMW.js";
 import {
   ideContextStore
-} from "./chunk-OTQ6PSZC.js";
+} from "./chunk-PHOF65IG.js";
 import {
   atomicWriteFileSync
-} from "./chunk-6X4GWOPW.js";
+} from "./chunk-A5L3JMUA.js";
 import {
   FatalConfigError,
   Storage,
   getErrorMessage
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QLJUC7TG.js → chunk-ZD6UTE4A.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-LX3COOXF.js → chunk-ZFDTEDCF.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-BSHD62QJ.js";
+} from "./chunk-M4FMGVY4.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
-import {
-  t
-} from "./chunk-VRRF3GW5.js";
 import {
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-4OWXOUYF.js";
+} from "./chunk-ZNAUOR2I.js";
+import {
+  t
+} from "./chunk-LKEJ26GS.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-ZJHVAS7M.js

@@ -0,0 +1,289 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getRateLimitErrorDetails
+} from "./chunk-6FGBXPWM.js";
+import {
+  isInternalPromptId
+} from "./chunk-CIKQ7KKO.js";
+import {
+  createDebugLogger
+} from "./chunk-NL7LTRLR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/openaiLogger.ts
+init_esbuild_shims();
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+
+// node_modules/uuid/dist/esm-node/index.js
+init_esbuild_shims();
+
+// node_modules/uuid/dist/esm-node/rng.js
+init_esbuild_shims();
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+__name(rng, "rng");
+
+// node_modules/uuid/dist/esm-node/stringify.js
+init_esbuild_shims();
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+__name(unsafeStringify, "unsafeStringify");
+
+// node_modules/uuid/dist/esm-node/v4.js
+init_esbuild_shims();
+
+// node_modules/uuid/dist/esm-node/native.js
+init_esbuild_shims();
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+__name(v4, "v4");
+var v4_default = v4;
+
+// packages/core/src/utils/openaiLogger.ts
+import * as os from "os";
+var debugLogger = createDebugLogger("OPENAI_LOGGER");
+var MAIN_SESSION_PROMPT_ID_DELIMITER = "########";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function resolveOpenAILogDir(customLogDir, cwd) {
+  const baseCwd = cwd || process.cwd();
+  if (!customLogDir) {
+    return path.join(baseCwd, "logs", "openai");
+  }
+  let resolvedPath = customLogDir;
+  if (customLogDir === "~" || customLogDir.startsWith("~/")) {
+    resolvedPath = path.join(os.homedir(), customLogDir.slice(1));
+  } else if (!path.isAbsolute(customLogDir)) {
+    resolvedPath = path.resolve(baseCwd, customLogDir);
+  }
+  return path.normalize(resolvedPath);
+}
+__name(resolveOpenAILogDir, "resolveOpenAILogDir");
+function sanitizeDiagnosticSuffix(suffix) {
+  if (!suffix) return void 0;
+  const sanitized = suffix.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || void 0;
+}
+__name(sanitizeDiagnosticSuffix, "sanitizeDiagnosticSuffix");
+function extractSubagentSuffix(promptId) {
+  const parts = promptId.split("#");
+  if (parts.length !== 3) return void 0;
+  const [, subagentId, turn] = parts;
+  if (!subagentId || !turn || !/^\d+$/.test(turn)) {
+    return void 0;
+  }
+  return `subagent-${subagentId}`;
+}
+__name(extractSubagentSuffix, "extractSubagentSuffix");
+function promptIdSuffixForFilename(promptId) {
+  if (!promptId) return void 0;
+  if (isInternalPromptId(promptId)) {
+    return sanitizeDiagnosticSuffix(promptId);
+  }
+  return sanitizeDiagnosticSuffix(extractSubagentSuffix(promptId));
+}
+__name(promptIdSuffixForFilename, "promptIdSuffixForFilename");
+function sessionIdFromPromptId(promptId) {
+  if (!promptId) return void 0;
+  const mainSessionDelimiterIndex = promptId.indexOf(
+    MAIN_SESSION_PROMPT_ID_DELIMITER
+  );
+  if (mainSessionDelimiterIndex > 0) {
+    return promptId.slice(0, mainSessionDelimiterIndex);
+  }
+  if (UUID_PATTERN.test(promptId)) {
+    return promptId;
+  }
+  const parts = promptId.split("#");
+  if (parts.length >= 3 && parts[0]) {
+    return parts[0];
+  }
+  return void 0;
+}
+__name(sessionIdFromPromptId, "sessionIdFromPromptId");
+function contextForPromptId(promptId) {
+  const trimmedPromptId = promptId?.trim();
+  const sessionId = sessionIdFromPromptId(trimmedPromptId);
+  if (!trimmedPromptId && !sessionId) {
+    return null;
+  }
+  return {
+    ...trimmedPromptId ? { promptId: trimmedPromptId } : {},
+    ...sessionId ? { sessionId } : {}
+  };
+}
+__name(contextForPromptId, "contextForPromptId");
+function getString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(getString, "getString");
+function getErrorRequestId(error) {
+  const source = error;
+  return getString(source.requestID) ?? getString(source.request_id) ?? getString(source.requestId) ?? getString(source.response_id) ?? getRateLimitErrorDetails(error).requestId;
+}
+__name(getErrorRequestId, "getErrorRequestId");
+function serializeError(error) {
+  const requestId = getErrorRequestId(error);
+  return {
+    message: error.message,
+    stack: error.stack,
+    ...requestId ? { requestId } : {}
+  };
+}
+__name(serializeError, "serializeError");
+var OpenAILogger = class {
+  static {
+    __name(this, "OpenAILogger");
+  }
+  logDir;
+  initialized = false;
+  /**
+   * Creates a new OpenAI logger
+   * @param customLogDir Optional custom log directory path (supports relative paths, absolute paths, and ~ expansion)
+   * @param cwd Optional working directory for resolving relative paths. Defaults to process.cwd().
+   *            In ACP mode, process.cwd() may be '/' (filesystem root), so callers should
+   *            pass the project working directory from Config.getWorkingDir().
+   */
+  constructor(customLogDir, cwd) {
+    this.logDir = resolveOpenAILogDir(customLogDir, cwd);
+  }
+  /**
+   * Initialize the logger by creating the log directory if it doesn't exist
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await fs.mkdir(this.logDir, { recursive: true });
+      this.initialized = true;
+    } catch (error) {
+      debugLogger.error("Failed to initialize OpenAI logger:", error);
+      throw new Error(`Failed to initialize OpenAI logger: ${error}`);
+    }
+  }
+  /**
+   * Logs an OpenAI API request and its response
+   * @param request The request sent to OpenAI
+   * @param response The response received from OpenAI
+   * @param error Optional error if the request failed
+   * @param promptId Optional prompt id; internal and subagent prompt ids are
+   *                 appended to the filename after timestamp and id.
+   * @returns The file path where the log was written
+   */
+  async logInteraction(request, response, error, promptId) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+    const id = v4_default().slice(0, 8);
+    const promptIdSuffix = promptIdSuffixForFilename(promptId);
+    const filename = promptIdSuffix ? `openai-${timestamp}-${id}-${promptIdSuffix}.json` : `openai-${timestamp}-${id}.json`;
+    const filePath = path.join(this.logDir, filename);
+    const logData = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      request,
+      response: response || null,
+      error: error ? serializeError(error) : null,
+      context: contextForPromptId(promptId),
+      system: {
+        hostname: os.hostname(),
+        platform: os.platform(),
+        release: os.release(),
+        nodeVersion: process.version
+      }
+    };
+    try {
+      await fs.writeFile(filePath, JSON.stringify(logData, null, 2), "utf-8");
+      return filePath;
+    } catch (writeError) {
+      debugLogger.error("Failed to write OpenAI log file:", writeError);
+      throw new Error(`Failed to write OpenAI log file: ${writeError}`);
+    }
+  }
+  /**
+   * Get all logged interactions
+   * @param limit Optional limit on the number of log files to return (sorted by most recent first)
+   * @returns Array of log file paths
+   */
+  async getLogFiles(limit) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      const files = await fs.readdir(this.logDir);
+      const logFiles = files.filter((file) => file.startsWith("openai-") && file.endsWith(".json")).map((file) => path.join(this.logDir, file)).sort().reverse();
+      return limit === void 0 ? logFiles : logFiles.slice(0, limit);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      debugLogger.error("Failed to read OpenAI log directory:", error);
+      return [];
+    }
+  }
+  /**
+   * Read a specific log file
+   * @param filePath The path to the log file
+   * @returns The log file content
+   */
+  async readLogFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      debugLogger.error(`Failed to read log file ${filePath}:`, error);
+      throw new Error(`Failed to read log file: ${error}`);
+    }
+  }
+};
+var openaiLogger = new OpenAILogger();
+
+export {
+  resolveOpenAILogDir,
+  OpenAILogger,
+  openaiLogger
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */