@cydm/pie 1.0.24 → 1.0.26

package/dist/chunks/{chunk-HAAYC2N5.js → chunk-64XJIKVK.js}

@@ -1560,12 +1560,12 @@ function Iterator(items, options) {
 function RequiredArray(properties) {
   return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
 }
-function _Object_(properties, options) {
+function _Object(properties, options) {
   const required = RequiredArray(properties);
   const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
   return CreateType(schema, options);
 }
-var Object2 = _Object_;
+var Object2 = _Object;
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
 function Promise2(item, options) {
@@ -3270,7 +3270,8 @@ function convertStats(stats) {
     isDirectory: stats.isDirectory(),
     isFile: stats.isFile(),
     size: stats.size,
-    mtime: stats.mtime
+    mtime: stats.mtime,
+    isSymbolicLink: stats.isSymbolicLink()
   };
 }
 function byteLength(text) {
@@ -3284,6 +3285,40 @@ function normalizeRangeOptions(options) {
     maxOutputBytes: Math.max(0, Math.floor(options?.maxOutputBytes ?? Number.POSITIVE_INFINITY))
   };
 }
+var StreamingBinaryDetector = class {
+  decoder = new TextDecoder("utf-8", { fatal: true });
+  byteCount = 0;
+  suspiciousControlCount = 0;
+  invalidUtf8 = false;
+  hasNul = false;
+  update(bytes) {
+    if (bytes.byteLength === 0) return;
+    this.byteCount += bytes.byteLength;
+    for (const byte of bytes) {
+      if (byte === 0) this.hasNul = true;
+      if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13 || byte === 127) {
+        this.suspiciousControlCount++;
+      }
+    }
+    if (!this.invalidUtf8) {
+      try {
+        this.decoder.decode(bytes, { stream: true });
+      } catch {
+        this.invalidUtf8 = true;
+      }
+    }
+  }
+  finish() {
+    if (!this.invalidUtf8) {
+      try {
+        this.decoder.decode();
+      } catch {
+        this.invalidUtf8 = true;
+      }
+    }
+    return this.invalidUtf8 || this.hasNul || this.byteCount > 0 && this.suspiciousControlCount / this.byteCount > 0.02;
+  }
+};
 var NodeFileSystem = class {
   platform = "node";
   sep;
@@ -3298,6 +3333,18 @@ var NodeFileSystem = class {
   readFileSync(path, encoding = "utf-8") {
     return getNodeFs().readFileSync(path, encoding);
   }
+  async readFilePrefix(path, maxBytes) {
+    const length = Math.max(0, Math.floor(maxBytes));
+    if (length === 0) return new Uint8Array();
+    const handle = await getNodeFs().promises.open(path, "r");
+    try {
+      const buffer = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, 0);
+      return new Uint8Array(buffer.subarray(0, bytesRead));
+    } finally {
+      await handle.close();
+    }
+  }
   async readTextRange(path, options, signal) {
     const fs = getNodeFs();
     const range = normalizeRangeOptions(options);
@@ -3320,6 +3367,10 @@ var NodeFileSystem = class {
     let truncated = false;
     let truncatedBy = null;
     let firstLineExceedsLimit = false;
+    const fileBinaryDetector = new StreamingBinaryDetector();
+    const selectedBinaryDetector = new StreamingBinaryDetector();
+    const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+    let rawLineIndex = 0;
     const selectedEndLine = Number.isFinite(range.limitLines) ? range.offsetLine + range.limitLines : Number.POSITIVE_INFINITY;
     const startLine = () => {
       if (lineStarted) return;
@@ -3395,23 +3446,41 @@ var NodeFileSystem = class {
       lineStarted = false;
       lineIndex++;
     };
-    const stream = fs.createReadStream(path, { encoding: "utf-8" });
+    const scanRawBytes = (bytes) => {
+      fileBinaryDetector.update(bytes);
+      let segmentStart = 0;
+      for (let index = 0; index < bytes.byteLength; index++) {
+        if (bytes[index] !== 10) continue;
+        if (rawLineIndex >= range.offsetLine && rawLineIndex < selectedEndLine) {
+          selectedBinaryDetector.update(bytes.subarray(segmentStart, index + 1));
+        }
+        rawLineIndex++;
+        segmentStart = index + 1;
+      }
+      if (segmentStart < bytes.byteLength && rawLineIndex >= range.offsetLine && rawLineIndex < selectedEndLine) {
+        selectedBinaryDetector.update(bytes.subarray(segmentStart));
+      }
+    };
+    const scanText = (text) => {
+      if (!text) return;
+      fullHasher.update(text);
+      for (const char of text) {
+        if (char === "\n") finishLine();
+        else scanLineChar(char);
+      }
+    };
+    const stream = fs.createReadStream(path);
     try {
       for await (const chunk of stream) {
         if (signal?.aborted) {
           stream.destroy();
           throw new Error("Operation aborted");
         }
-        const text = String(chunk);
-        fullHasher.update(text);
-        for (const char of text) {
-          if (char === "\n") {
-            finishLine();
-          } else {
-            scanLineChar(char);
-          }
-        }
+        const bytes = chunk;
+        scanRawBytes(bytes);
+        scanText(textDecoder.decode(bytes, { stream: true }));
       }
+      scanText(textDecoder.decode());
       finishLine();
     } finally {
       stream.destroy();
@@ -3430,6 +3499,8 @@ var NodeFileSystem = class {
       truncated,
       truncatedBy,
       firstLineExceedsLimit,
+      selectedBytesLookBinary: selectedBinaryDetector.finish(),
+      fileBytesLookBinary: fileBinaryDetector.finish(),
       mtimeMs: stat.mtime.getTime(),
       size: stat.size
     };
@@ -3450,6 +3521,28 @@ var NodeFileSystem = class {
   async readdir(path) {
     return getNodeFs().promises.readdir(path);
   }
+  async readDirectoryBounded(path, limit, signal) {
+    if (!Number.isSafeInteger(limit) || limit < 0) throw new Error("directory entry limit must be a non-negative safe integer");
+    if (signal?.aborted) throw new Error("Operation aborted");
+    const entries = [];
+    const directory = await getNodeFs().promises.opendir(path);
+    let limitReached = false;
+    try {
+      while (entries.length <= limit) {
+        if (signal?.aborted) throw new Error("Operation aborted");
+        const entry = await directory.read();
+        if (!entry) break;
+        if (entries.length === limit) {
+          limitReached = true;
+          break;
+        }
+        entries.push(entry.name);
+      }
+    } finally {
+      await directory.close().catch(() => void 0);
+    }
+    return { entries, limitReached };
+  }
   readdirSync(path) {
     return getNodeFs().readdirSync(path);
   }
@@ -3477,6 +3570,15 @@ var NodeFileSystem = class {
     entry.name = getNodePath().basename(path);
     return entry;
   }
+  lstatSync(path) {
+    const stats = getNodeFs().lstatSync(path);
+    const entry = convertStats(stats);
+    entry.name = getNodePath().basename(path);
+    return entry;
+  }
+  realpathSync(path) {
+    return getNodeFs().realpathSync(path);
+  }
   async access(path, mode) {
     await getNodeFs().promises.access(path, mode);
   }
@@ -3537,6 +3639,35 @@ async function taskToPromise(task) {
   }
   return task;
 }
+function getFileCompletionStore() {
+  const globalValue = globalThis;
+  if (!globalValue.__pieFileCompletionStore) {
+    globalValue.__pieFileCompletionStore = { completions: /* @__PURE__ */ new Map(), waiters: /* @__PURE__ */ new Map() };
+  }
+  if (!globalValue._pieFileComplete) {
+    globalValue._pieFileComplete = (requestId, resultJson, error) => {
+      const store = getFileCompletionStore();
+      const completion = { resultJson, error };
+      const waiter = store.waiters.get(requestId);
+      if (waiter) {
+        store.waiters.delete(requestId);
+        waiter(completion);
+      } else {
+        store.completions.set(requestId, completion);
+      }
+    };
+  }
+  return globalValue.__pieFileCompletionStore;
+}
+function waitForFileCompletion(requestId) {
+  const store = getFileCompletionStore();
+  const existing = store.completions.get(requestId);
+  if (existing) {
+    store.completions.delete(requestId);
+    return Promise.resolve(existing);
+  }
+  return new Promise((resolve) => store.waiters.set(requestId, resolve));
+}
 function toJsStringArray(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => String(entry ?? ""));
@@ -3566,6 +3697,11 @@ function normalizeOptionalNumber(value, fallback) {
   }
   return Math.max(0, Math.floor(value));
 }
+function normalizeInt32(value, fallback) {
+  const normalized = normalizeOptionalNumber(value, fallback);
+  if (!Number.isSafeInteger(normalized) || normalized > 2147483647) throw new Error("Unity range-read arguments exceed Int32 bounds");
+  return normalized;
+}
 function convertTextRangeResult(result) {
   return {
     content: String(result?.Content ?? ""),
@@ -3581,66 +3717,12 @@ function convertTextRangeResult(result) {
     truncated: !!result?.Truncated,
     truncatedBy: result?.TruncatedBy ? String(result.TruncatedBy) : null,
     firstLineExceedsLimit: !!result?.FirstLineExceedsLimit,
+    ...typeof result?.SelectedBytesLookBinary === "boolean" ? { selectedBytesLookBinary: result.SelectedBytesLookBinary } : {},
+    ...typeof result?.FileBytesLookBinary === "boolean" ? { fileBytesLookBinary: result.FileBytesLookBinary } : {},
     mtimeMs: (Number(result?.LastWriteTicksUtc || 0) - 621355968e9) / 1e4,
     size: Number(result?.Size ?? 0)
   };
 }
-function byteLength2(text) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.byteLength(text, "utf-8");
-  }
-  return unescape(encodeURIComponent(text)).length;
-}
-function buildTextRangeFallback(content, stat, offsetLine, limitLines, maxOutputLines, maxOutputBytes) {
-  const lines = content.split("\n");
-  const endLine = Number.isFinite(limitLines) ? Math.min(lines.length, offsetLine + limitLines) : lines.length;
-  const selectedLinesArray = offsetLine >= lines.length ? [] : lines.slice(offsetLine, endLine);
-  const selectedContent = selectedLinesArray.join("\n");
-  const outputLines = [];
-  let outputBytes = 0;
-  let truncated = false;
-  let truncatedBy = null;
-  let firstLineExceedsLimit = false;
-  for (const line of selectedLinesArray) {
-    const lineBytes = byteLength2(line);
-    if (outputLines.length === 0 && lineBytes > maxOutputBytes) {
-      firstLineExceedsLimit = true;
-      truncated = true;
-      truncatedBy = "bytes";
-      break;
-    }
-    if (outputLines.length >= maxOutputLines) {
-      truncated = true;
-      truncatedBy = "lines";
-      break;
-    }
-    const candidateBytes = lineBytes + (outputLines.length > 0 ? 1 : 0);
-    if (outputBytes + candidateBytes > maxOutputBytes) {
-      truncated = true;
-      truncatedBy = "bytes";
-      break;
-    }
-    outputLines.push(line);
-    outputBytes += candidateBytes;
-  }
-  return {
-    content: outputLines.join("\n"),
-    contentHash: hashText(content),
-    selectedContentHash: hashText(selectedContent),
-    totalLines: lines.length,
-    totalBytes: stat.size,
-    selectedLines: selectedLinesArray.length,
-    selectedBytes: byteLength2(selectedContent),
-    firstLineBytes: selectedLinesArray.length > 0 ? byteLength2(selectedLinesArray[0]) : 0,
-    outputLines: outputLines.length,
-    outputBytes,
-    truncated,
-    truncatedBy,
-    firstLineExceedsLimit,
-    mtimeMs: stat.mtime.getTime(),
-    size: stat.size
-  };
-}
 function convertDateTime(dateTime) {
   if (!dateTime) return /* @__PURE__ */ new Date(0);
   const ticks = dateTime.get_Ticks?.() || 0;
@@ -3667,6 +3749,9 @@ function convertFileSystemInfo(info) {
     mtime: info.LastWriteTimeUtc ? convertDateTime(info.LastWriteTimeUtc) : /* @__PURE__ */ new Date(0)
   };
 }
+function fileNameFromPath(IO, path) {
+  return String(IO.Path.GetFileName(path) || IO.Path.GetPathRoot(path) || path);
+}
 var PuerTSFileSystem = class {
   platform = "puerts";
   sep = "/";
@@ -3706,32 +3791,62 @@ var PuerTSFileSystem = class {
     }
     return IO.File.ReadAllText(normalizedPath);
   }
+  async readFilePrefix(path, maxBytes) {
+    const IO = getSystemIO();
+    const normalizedPath = this.normalizePath(path);
+    if (!IO.File.Exists(normalizedPath)) {
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+    const length = Math.max(0, Math.floor(maxBytes));
+    if (length === 0) return new Uint8Array();
+    const stream = IO.File.OpenRead(normalizedPath);
+    try {
+      const count = Math.min(length, Number(stream.Length));
+      const buffer = CS.System.Array.CreateInstance(CS.System.Byte, count);
+      const bytesRead = Number(stream.Read(buffer, 0, count));
+      const result = new Uint8Array(bytesRead);
+      for (let index = 0; index < bytesRead; index += 1) {
+        result[index] = Number(buffer.GetValue(index));
+      }
+      return result;
+    } finally {
+      stream.Dispose();
+    }
+  }
   async readTextRange(path, options, signal) {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
     const bridge = getPieFileBridge();
     const normalizedPath = this.normalizePath(path);
-    if (typeof bridge.ReadTextRangeAsync !== "function") {
-      const content = await this.readFile(path, "utf-8");
-      const stat = await this.stat(path);
-      const offsetLine = normalizeOptionalNumber(options?.offsetLine, 0);
-      const limitLines = options?.limitLines === void 0 ? Number.POSITIVE_INFINITY : normalizeOptionalNumber(options.limitLines, 0);
-      const maxOutputLines = normalizeOptionalNumber(options?.maxOutputLines, Number.POSITIVE_INFINITY);
-      const maxOutputBytes = normalizeOptionalNumber(options?.maxOutputBytes, Number.POSITIVE_INFINITY);
-      return buildTextRangeFallback(content, stat, offsetLine, limitLines, maxOutputLines, maxOutputBytes);
-    }
-    const payload = await taskToPromise(bridge.ReadTextRangeAsync(
+    if (typeof bridge.StartReadTextRange !== "function" || typeof bridge.CancelRequest !== "function" || typeof bridge.ReleaseRequest !== "function") {
+      throw new Error("The Unity host does not provide the cancellable bounded range-read bridge required by read_file.");
+    }
+    const requestId = Number(bridge.StartReadTextRange(
       normalizedPath,
-      normalizeOptionalNumber(options?.offsetLine, 0),
-      options?.limitLines === void 0 ? -1 : normalizeOptionalNumber(options.limitLines, 0),
-      normalizeOptionalNumber(options?.maxOutputLines, -1),
-      normalizeOptionalNumber(options?.maxOutputBytes, -1)
+      normalizeInt32(options?.offsetLine, 0),
+      options?.limitLines === void 0 ? -1 : normalizeInt32(options.limitLines, 0),
+      normalizeInt32(options?.maxOutputLines, -1),
+      normalizeInt32(options?.maxOutputBytes, -1)
     ));
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
+    if (!Number.isSafeInteger(requestId) || requestId <= 0) {
+      throw new Error("The Unity range-read bridge returned an invalid request id.");
+    }
+    const onAbort = () => bridge.CancelRequest(requestId);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      if (signal?.aborted) bridge.CancelRequest(requestId);
+      const completion = await waitForFileCompletion(requestId);
+      if (completion.error) throw new Error(completion.error);
+      if (signal?.aborted) throw new Error("Operation aborted");
+      return convertTextRangeResult(JSON.parse(String(completion.resultJson ?? "{}")));
+    } finally {
+      const store = getFileCompletionStore();
+      store.completions.delete(requestId);
+      store.waiters.delete(requestId);
+      signal?.removeEventListener("abort", onAbort);
+      bridge.ReleaseRequest(requestId);
     }
-    return convertTextRangeResult(JSON.parse(String(payload ?? "{}")));
   }
   async writeFile(path, data, encoding = "utf-8") {
     const bridge = getPieFileBridge();
@@ -3789,6 +3904,32 @@ var PuerTSFileSystem = class {
     const entries = await taskToPromise(bridge.ReadDirectoryAsync(normalizedPath));
     return toJsStringArray(entries);
   }
+  async readDirectoryBounded(path, limit, signal) {
+    if (!Number.isSafeInteger(limit) || limit < 0 || limit > 2147483647) throw new Error("directory entry limit must be between 0 and 2147483647");
+    if (signal?.aborted) throw new Error("Operation aborted");
+    const IO = getSystemIO();
+    const bridge = getPieFileBridge();
+    const normalizedPath = this.normalizePath(path);
+    if (!IO.Directory.Exists(normalizedPath)) throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+    if (typeof bridge.StartReadDirectoryBounded !== "function") throw new Error("The Unity host does not provide bounded cancellable directory enumeration.");
+    const requestId = Number(bridge.StartReadDirectoryBounded(normalizedPath, limit));
+    const onAbort = () => bridge.CancelRequest(requestId);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      if (signal?.aborted) bridge.CancelRequest(requestId);
+      const completion = await waitForFileCompletion(requestId);
+      if (completion.error) throw new Error(completion.error);
+      if (signal?.aborted) throw new Error("Operation aborted");
+      const result = JSON.parse(String(completion.resultJson ?? "{}"));
+      return { entries: toJsStringArray(result?.Entries), limitReached: !!result?.LimitReached };
+    } finally {
+      const store = getFileCompletionStore();
+      store.completions.delete(requestId);
+      store.waiters.delete(requestId);
+      signal?.removeEventListener("abort", onAbort);
+      bridge.ReleaseRequest(requestId);
+    }
+  }
   readdirSync(path) {
     const IO = getSystemIO();
     const normalizedPath = this.normalizePath(path);
@@ -3840,6 +3981,49 @@ var PuerTSFileSystem = class {
     }
     throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
   }
+  lstatSync(path) {
+    const IO = getSystemIO();
+    const normalizedPath = this.normalizePath(path);
+    let attributes;
+    try {
+      attributes = Number(IO.File.GetAttributes(normalizedPath));
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, lstat '${path}'`);
+    }
+    const isSymbolicLink = (attributes & Number(IO.FileAttributes.ReparsePoint)) !== 0;
+    if (!isSymbolicLink) {
+      return this.statSync(path);
+    }
+    return {
+      name: fileNameFromPath(IO, normalizedPath),
+      isDirectory: false,
+      isFile: false,
+      isSymbolicLink: true,
+      size: 0,
+      mtime: /* @__PURE__ */ new Date(0)
+    };
+  }
+  realpathSync(path) {
+    const IO = getSystemIO();
+    const fullPath = this.normalizePath(String(IO.Path.GetFullPath(this.normalizePath(path))));
+    const root = this.normalizePath(String(IO.Path.GetPathRoot(fullPath) || ""));
+    const relative = fullPath.slice(root.length);
+    const parts = relative.split("/").filter(Boolean);
+    let cursor = root;
+    for (const part of parts) {
+      cursor = cursor ? this.normalizePath(String(IO.Path.Combine(cursor, part))) : part;
+      let attributes;
+      try {
+        attributes = Number(IO.File.GetAttributes(cursor));
+      } catch {
+        throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+      }
+      if ((attributes & Number(IO.FileAttributes.ReparsePoint)) !== 0) {
+        throw new Error(`Symbolic links are not supported by the Unity filesystem sandbox: ${cursor}`);
+      }
+    }
+    return fullPath;
+  }
   async access(path, mode) {
     const IO = getSystemIO();
     const normalizedPath = this.normalizePath(path);
@@ -5369,6 +5553,54 @@ function logEmptyAssistantContentError(error, model, options) {
 }
 
 // ../../packages/ai/src/providers/openai-compat.ts
+function normalizeTokenCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function mergeOpenAIUsage(previous, usage) {
+  return {
+    promptTokens: normalizeTokenCount(usage?.prompt_tokens) ?? previous.promptTokens,
+    completionTokens: normalizeTokenCount(usage?.completion_tokens) ?? previous.completionTokens,
+    cachedTokens: normalizeTokenCount(usage?.prompt_tokens_details?.cached_tokens) ?? previous.cachedTokens,
+    reasoningTokens: normalizeTokenCount(usage?.completion_tokens_details?.reasoning_tokens) ?? previous.reasoningTokens,
+    totalTokens: normalizeTokenCount(usage?.total_tokens) ?? previous.totalTokens
+  };
+}
+function normalizeOpenAIUsage(usage) {
+  const reportedPromptTokens = usage.promptTokens;
+  const reportedCachedTokens = usage.cachedTokens;
+  const reportedCompletionTokens = usage.completionTokens;
+  const reportedReasoningTokens = usage.reasoningTokens;
+  const reportedTotalTokens = usage.totalTokens;
+  const cachedTokens = reportedCachedTokens ?? 0;
+  const promptTokens = reportedPromptTokens ?? (reportedTotalTokens !== void 0 && reportedCompletionTokens !== void 0 ? Math.max(cachedTokens, reportedTotalTokens - reportedCompletionTokens) : cachedTokens);
+  const cacheRead = Math.min(cachedTokens, promptTokens);
+  const input = promptTokens - cacheRead;
+  const output = reportedCompletionTokens ?? (reportedTotalTokens !== void 0 ? Math.max(reportedReasoningTokens ?? 0, reportedTotalTokens - promptTokens) : reportedReasoningTokens ?? 0);
+  const partitionTotal = promptTokens + output;
+  return {
+    input,
+    output,
+    cacheRead,
+    totalTokens: Math.max(reportedTotalTokens ?? 0, partitionTotal)
+  };
+}
+function formatOpenAIStreamError(error) {
+  if (!error || typeof error !== "object") {
+    return typeof error === "string" ? error : "OpenAI-compatible stream returned an error";
+  }
+  const message = typeof error.message === "string" && error.message.length > 0 ? error.message : "OpenAI-compatible stream returned an error";
+  const metadata = [];
+  if (typeof error.type === "string" && error.type.length > 0) {
+    metadata.push(`type=${error.type}`);
+  }
+  if (typeof error.code === "string" && error.code.length > 0) {
+    metadata.push(`code=${error.code}`);
+  }
+  return metadata.length > 0 ? `${message} (${metadata.join(", ")})` : message;
+}
 var streamOpenAICompletions = (model, context, options) => {
   const stream = new AssistantMessageEventStream();
   (async () => {
@@ -5418,6 +5650,7 @@ var streamOpenAICompletions = (model, context, options) => {
       let currentBlock = null;
       const blocks = output.content;
       const blockIndex = () => blocks.length - 1;
+      let usageSnapshot = {};
       const finishCurrentBlock = (block) => {
         if (block) {
           if (block.type === "text") {
@@ -5462,26 +5695,28 @@ var streamOpenAICompletions = (model, context, options) => {
             } catch {
               continue;
             }
+            if (chunk?.error) {
+              throw new Error(formatOpenAIStreamError(chunk.error));
+            }
             if (chunk.usage) {
-              const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens || 0;
-              const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens || 0;
-              const input = (chunk.usage.prompt_tokens || 0) - cachedTokens;
-              const outputTokens = (chunk.usage.completion_tokens || 0) + reasoningTokens;
+              usageSnapshot = mergeOpenAIUsage(usageSnapshot, chunk.usage);
+              const normalizedUsage = normalizeOpenAIUsage(usageSnapshot);
               output.usage = {
-                input,
-                output: outputTokens,
-                cacheRead: cachedTokens,
+                input: normalizedUsage.input,
+                output: normalizedUsage.output,
+                cacheRead: normalizedUsage.cacheRead,
                 cacheWrite: 0,
-                totalTokens: input + outputTokens + cachedTokens,
+                totalTokens: normalizedUsage.totalTokens,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
               };
-              calculateCost(model, output.usage);
+              output.usage.cost = calculateCost(model, output.usage);
               if (process.env.PIE_DEBUG_CACHE) {
+                const normalizedPromptTokens = normalizedUsage.input + normalizedUsage.cacheRead;
                 console.error("[CACHE DEBUG] Response usage:", JSON.stringify({
-                  input_tokens: input,
-                  output_tokens: outputTokens,
-                  cached_tokens: cachedTokens,
-                  cache_hit_rate: chunk.usage.prompt_tokens ? `${(cachedTokens / chunk.usage.prompt_tokens * 100).toFixed(1)}%` : "N/A"
+                  input_tokens: normalizedUsage.input,
+                  output_tokens: normalizedUsage.output,
+                  cached_tokens: normalizedUsage.cacheRead,
+                  cache_hit_rate: normalizedPromptTokens > 0 ? `${(normalizedUsage.cacheRead / normalizedPromptTokens * 100).toFixed(1)}%` : "N/A"
                 }, null, 2));
               }
             }