@cydm/pie 2.6.4 → 2.6.6

package/dist/chunks/{chunk-OCEYHWVX.js → chunk-G5B6D35K.js}

@@ -722,6 +722,9 @@ var NodeFileSystem = class {
     }
   }
   async readTextRange(path, options, signal) {
+    if (options?.tailLines !== void 0) {
+      return this.readTextRangeTail(path, options, signal);
+    }
     const fs = getNodeFs();
     const range = normalizeRangeOptions(options);
     const stat = await fs.promises.stat(path);
@@ -747,6 +750,7 @@ var NodeFileSystem = class {
     const selectedBinaryDetector = new StreamingBinaryDetector();
     const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
     let rawLineIndex = 0;
+    let lastCharWasNewline = false;
     const selectedEndLine = Number.isFinite(range.limitLines) ? range.offsetLine + range.limitLines : Number.POSITIVE_INFINITY;
     const startLine = () => {
       if (lineStarted) return;
@@ -843,6 +847,7 @@ var NodeFileSystem = class {
       for (const char of text) {
         if (char === "\n") finishLine();
         else scanLineChar(char);
+        lastCharWasNewline = char === "\n";
       }
     };
     const stream = fs.createReadStream(path);
@@ -877,6 +882,181 @@ var NodeFileSystem = class {
       firstLineExceedsLimit,
       selectedBytesLookBinary: selectedBinaryDetector.finish(),
       fileBytesLookBinary: fileBinaryDetector.finish(),
+      endsWithNewline: lastCharWasNewline,
+      mtimeMs: stat.mtime.getTime(),
+      size: stat.size
+    };
+  }
+  /**
+   * Tail read: select the last N lines in ONE forward scan. The full-file
+   * hash and totalLines (which the observation ledger requires of every
+   * read) force a complete scan anyway, so the tail window is extracted with
+   * a bounded ring buffer during that same scan — no probing passes, no
+   * second/third read. Ring bounds: at most `effectiveN` line entries and
+   * 2×maxOutputBytes of text; a single line longer than maxOutputBytes keeps
+   * only its byte length (it can never be output). When the ring evicts
+   * older lines (window bytes over budget), the result degrades honestly:
+   * truncated=true, and the reported window covers exactly what was kept.
+   */
+  async readTextRangeTail(path, options, signal) {
+    const fs = getNodeFs();
+    const stat = await fs.promises.stat(path);
+    const maxOutputLines = Number.isFinite(options.maxOutputLines) ? Math.max(0, Math.floor(options.maxOutputLines)) : Number.POSITIVE_INFINITY;
+    const maxOutputBytes = Number.isFinite(options.maxOutputBytes) ? Math.max(0, Math.floor(options.maxOutputBytes)) : Number.POSITIVE_INFINITY;
+    const requested = Math.max(1, Math.floor(options.tailLines));
+    const effectiveN = Math.max(1, Math.min(requested, maxOutputLines));
+    const fullHasher = createTextHasher();
+    const fileBinaryDetector = new StreamingBinaryDetector();
+    const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+    const entries = [];
+    let entryBytes = 0;
+    let totalLines = 0;
+    let lastCharWasNewline = false;
+    let currentLine = "";
+    let currentLineBytes = 0;
+    let keepLineText = true;
+    const ringByteBudget = Number.isFinite(maxOutputBytes) ? 2 * maxOutputBytes : Number.POSITIVE_INFINITY;
+    const trimRing = () => {
+      while (entries.length > effectiveN || entries.length > 1 && entryBytes > ringByteBudget) {
+        const evicted = entries.shift();
+        entryBytes -= evicted.bytes;
+      }
+    };
+    const scanText = (text) => {
+      if (!text) return;
+      fullHasher.update(text);
+      for (const char of text) {
+        if (char === "\n") {
+          entries.push({ text: keepLineText ? currentLine : null, bytes: currentLineBytes });
+          entryBytes += currentLineBytes;
+          totalLines++;
+          currentLine = "";
+          currentLineBytes = 0;
+          keepLineText = true;
+          trimRing();
+        } else {
+          const charBytes = byteLength(char);
+          currentLineBytes += charBytes;
+          if (currentLineBytes > maxOutputBytes) {
+            keepLineText = false;
+            currentLine = "";
+          } else {
+            currentLine += char;
+          }
+        }
+        lastCharWasNewline = char === "\n";
+      }
+    };
+    const stream = fs.createReadStream(path);
+    try {
+      for await (const chunk of stream) {
+        if (signal?.aborted) {
+          stream.destroy();
+          throw new Error("Operation aborted");
+        }
+        const bytes = chunk;
+        fileBinaryDetector.update(bytes);
+        scanText(textDecoder.decode(bytes, { stream: true }));
+      }
+      scanText(textDecoder.decode());
+    } finally {
+      stream.destroy();
+    }
+    if (lastCharWasNewline) {
+      totalLines++;
+    } else if (currentLine !== "" || currentLineBytes > 0) {
+      entries.push({ text: keepLineText ? currentLine : null, bytes: currentLineBytes });
+      entryBytes += currentLineBytes;
+      totalLines++;
+      trimRing();
+    } else if (totalLines === 0) {
+      totalLines = 1;
+    }
+    const phantomIncluded = lastCharWasNewline;
+    const emptyFileSingleLine = entries.length === 0 && !phantomIncluded && totalLines === 1;
+    const windowLines = entries.length + (phantomIncluded ? 1 : 0) + (emptyFileSingleLine ? 1 : 0);
+    const selectedBytes = entries.reduce((sum, entry) => sum + entry.bytes, 0) + Math.max(0, windowLines - 1);
+    const firstLineBytes = entries.length > 0 ? entries[0].bytes : 0;
+    const firstLineExceedsLimit = entries.length === 1 && entries[0].text === null;
+    const streamedLines = totalLines - (phantomIncluded ? 1 : 0) - (emptyFileSingleLine ? 1 : 0);
+    const lostWindowLines = Math.max(0, Math.min(streamedLines, effectiveN) - entries.length);
+    const outputLines = [];
+    let outputBytes = 0;
+    let truncated = lostWindowLines > 0;
+    let truncatedBy = lostWindowLines > 0 ? "bytes" : null;
+    let firstShownEntryIndex;
+    const phantomReserve = phantomIncluded && !emptyFileSingleLine ? 1 : 0;
+    for (let index = entries.length - 1; index >= 0; index--) {
+      const entry = entries[index];
+      if (outputLines.length + phantomReserve >= maxOutputLines) {
+        truncated = true;
+        truncatedBy = truncatedBy ?? "lines";
+        break;
+      }
+      if (entry.text === null) {
+        truncated = true;
+        truncatedBy = "bytes";
+        break;
+      }
+      const candidate = outputBytes + (outputLines.length > 0 ? 1 : 0) + entry.bytes;
+      if (candidate > maxOutputBytes) {
+        truncated = true;
+        truncatedBy = "bytes";
+        break;
+      }
+      outputLines.unshift(entry.text);
+      outputBytes = candidate;
+      firstShownEntryIndex = index;
+    }
+    if (phantomIncluded) {
+      if (outputLines.length + 1 <= maxOutputLines || outputLines.length === 0) {
+        const phantomBytes = outputLines.length > 0 ? 1 : 0;
+        if (outputBytes + phantomBytes <= maxOutputBytes) {
+          outputLines.push("");
+          outputBytes += phantomBytes;
+        } else {
+          truncated = true;
+          truncatedBy = "bytes";
+        }
+      } else {
+        truncated = true;
+        truncatedBy = truncatedBy ?? "lines";
+      }
+    }
+    if (emptyFileSingleLine) {
+      outputLines.push("");
+    }
+    if (firstLineExceedsLimit) {
+      truncated = true;
+      truncatedBy = "bytes";
+    }
+    const realLastLine = totalLines - (phantomIncluded ? 1 : 0);
+    const outputStartLine = outputLines.length === 0 ? totalLines + 1 : firstShownEntryIndex !== void 0 ? realLastLine - entries.length + 1 + firstShownEntryIndex : totalLines;
+    const content = outputLines.join("\n");
+    const selectedHasher = createTextHasher();
+    selectedHasher.update(content);
+    const selectedBinaryDetector = new StreamingBinaryDetector();
+    if (content.length > 0) {
+      selectedBinaryDetector.update(Buffer.from(content, "utf-8"));
+    }
+    return {
+      content,
+      contentHash: fullHasher.digest(),
+      selectedContentHash: selectedHasher.digest(),
+      totalLines,
+      totalBytes: stat.size,
+      selectedLines: windowLines,
+      selectedBytes,
+      firstLineBytes,
+      outputLines: outputLines.length,
+      outputBytes,
+      truncated,
+      truncatedBy,
+      firstLineExceedsLimit,
+      selectedBytesLookBinary: selectedBinaryDetector.finish(),
+      fileBytesLookBinary: fileBinaryDetector.finish(),
+      endsWithNewline: lastCharWasNewline,
+      outputStartLine,
       mtimeMs: stat.mtime.getTime(),
       size: stat.size
     };
@@ -1206,6 +1386,9 @@ var PuerTSFileSystem = class {
     if (signal?.aborted) {
       throw new Error("Operation aborted");
     }
+    if (options?.tailLines !== void 0 && Number.isFinite(options.tailLines) && options.tailLines > 0) {
+      return this.readTextRangeTailViaBridge(path, options, signal);
+    }
     const bridge = getPieFileBridge();
     const normalizedPath = this.normalizePath(path);
     if (typeof bridge.StartReadTextRange !== "function" || typeof bridge.CancelRequest !== "function" || typeof bridge.ReleaseRequest !== "function") {
@@ -1237,6 +1420,71 @@ var PuerTSFileSystem = class {
       bridge.ReleaseRequest(requestId);
     }
   }
+  /**
+   * Tail fallback for the PuerTS host: the Unity C# bridge has no native
+   * tail support yet (follow-up: a purpose-built bridge method mirroring
+   * NodeFileSystem's single-scan ring buffer). Until then, translate
+   * tailLines into the bridge's offset/limit windows — a 1-line probe for
+   * the line count, one for phantom detection, then the window read. The
+   * extra scans stay inside the platform so every caller (the shared read
+   * tool, future hosts) sees one uniform tailLines contract.
+   *
+   * Two contract guards live here because the bridge reads windows FORWARD:
+   * 1. The C# side keeps the window's HEAD under the byte cap — the opposite
+   *    of tail semantics. Halve the window until it fits so the delivered
+   *    content always ends at the file's last line (matching NodeFileSystem);
+   *    a single over-cap line degrades to firstLineExceedsLimit, the same
+   *    signal Node produces.
+   * 2. Out-of-band appends between the probes and the window read would
+   *    stale the line count; verify mtime stability and retry a bounded
+   *    number of times, then fall through best-effort (append-heavy logs
+   *    legitimately churn).
+   */
+  async readTextRangeTailViaBridge(path, options, signal) {
+    const probeOptions = {
+      offsetLine: 0,
+      limitLines: 1,
+      maxOutputLines: 1,
+      maxOutputBytes: options.maxOutputBytes
+    };
+    const maxOutputLines = Number.isFinite(options.maxOutputLines) ? Math.floor(options.maxOutputLines) : Number.POSITIVE_INFINITY;
+    for (let attempt = 0; ; attempt++) {
+      const countProbe = await this.readTextRange(path, probeOptions, signal);
+      const totalLines = countProbe.totalLines;
+      const requested = Math.floor(options.tailLines);
+      let effectiveN = Math.max(1, Math.min(requested, maxOutputLines));
+      const lastProbe = await this.readTextRange(path, { ...probeOptions, offsetLine: Math.max(0, totalLines - 1) }, signal);
+      const phantom = lastProbe.selectedBytes === 0 && !lastProbe.firstLineExceedsLimit && totalLines > 1;
+      let result;
+      let windowOffsetLine = 0;
+      for (; ; ) {
+        windowOffsetLine = Math.max(0, totalLines - effectiveN - (phantom ? 1 : 0));
+        result = await this.readTextRange(path, {
+          offsetLine: windowOffsetLine,
+          limitLines: effectiveN + (phantom ? 1 : 0),
+          maxOutputLines: options.maxOutputLines,
+          maxOutputBytes: options.maxOutputBytes
+        }, signal);
+        const byteTruncated = result.truncated && result.truncatedBy === "bytes" && !result.firstLineExceedsLimit;
+        const oversizedHead = result.truncated && result.firstLineExceedsLimit;
+        if (byteTruncated && effectiveN > 1) {
+          effectiveN = Math.max(1, Math.floor(effectiveN / 2));
+          continue;
+        }
+        if (oversizedHead) {
+          const nextEffectiveN = totalLines - (phantom ? 1 : 0) - (windowOffsetLine + 1);
+          if (nextEffectiveN < 1 || nextEffectiveN >= effectiveN) break;
+          effectiveN = nextEffectiveN;
+          continue;
+        }
+        break;
+      }
+      const stable = countProbe.mtimeMs === lastProbe.mtimeMs && lastProbe.mtimeMs === result.mtimeMs && countProbe.contentHash === lastProbe.contentHash && lastProbe.contentHash === result.contentHash;
+      if (stable || attempt >= 2) {
+        return { ...result, endsWithNewline: phantom, outputStartLine: windowOffsetLine + 1 };
+      }
+    }
+  }
   async writeFile(path, data, encoding = "utf-8") {
     const bridge = getPieFileBridge();
     const normalizedPath = this.normalizePath(path);
@@ -1755,6 +2003,7 @@ var NodeHttpClient = class {
             let done = false;
             let error = null;
             let waiting = null;
+            let consumerClosed = false;
             const wake = (value) => {
               if (!waiting) return;
               const w = waiting;
@@ -1840,6 +2089,7 @@ var NodeHttpClient = class {
               failStream(requestTimeoutError ?? new Error("SSE stream aborted"));
             });
             res.on("close", () => {
+              if (consumerClosed) return;
               if (!done || !res.complete) {
                 failStream(requestTimeoutError ?? new Error("SSE stream closed before end"));
               }
@@ -1865,6 +2115,7 @@ var NodeHttpClient = class {
                 void waitResult;
               }
             } finally {
+              consumerClosed = true;
               if (signal && abortHandler) {
                 signal.removeEventListener("abort", abortHandler);
               }
@@ -2524,9 +2775,19 @@ var FileSystemGateway = class {
     const recursive = options?.recursive ?? true;
     const platform = detectPlatform();
     if (platform === "puerts" && typeof CS !== "undefined") {
-      if (CS.System.IO.Directory.Exists(path)) {
+      if (!CS.System.IO.Directory.Exists(path)) {
+        return;
+      }
+      if (typeof CS.System.IO.Directory.Delete === "function") {
         CS.System.IO.Directory.Delete(path, recursive);
+        return;
       }
+      const info = new CS.System.IO.DirectoryInfo(path);
+      if (info && typeof info.Delete === "function") {
+        info.Delete(recursive);
+        return;
+      }
+      deletePuertsDirectoryByEnumeration(path, recursive);
       return;
     }
     const fs = nodeRequire("fs");
@@ -2549,9 +2810,20 @@ var FileSystemGateway = class {
         throw new Error(`Directory not found: ${source}`);
       }
       if (CS.System.IO.Directory.Exists(destination)) {
-        throw new Error(`Move target already exists: ${destination}`);
+        const destinationFiles = Array.from(CS.System.IO.Directory.GetFiles(destination) ?? []);
+        const destinationDirs = Array.from(CS.System.IO.Directory.GetDirectories(destination) ?? []);
+        const isEmpty = destinationFiles.length === 0 && destinationDirs.length === 0;
+        if (!isEmpty) {
+          throw new Error(`Move target already exists: ${destination}`);
+        }
+        movePuertsDirectoryContents(source, destination);
+        return;
+      }
+      if (typeof CS.System.IO.Directory.Move === "function") {
+        CS.System.IO.Directory.Move(source, destination);
+      } else {
+        new CS.System.IO.DirectoryInfo(source).MoveTo(destination);
       }
-      CS.System.IO.Directory.Move(source, destination);
       return;
     }
     const fs = nodeRequire("fs");
@@ -2671,6 +2943,100 @@ var FileSystemGateway = class {
     return this.config;
   }
 };
+function movePuertsDirectoryContents(source, destination) {
+  const directory = CS.System.IO.Directory;
+  const file = CS.System.IO.File;
+  if (typeof directory.GetFiles !== "function" || typeof directory.GetDirectories !== "function" || typeof directory.CreateDirectory !== "function" || typeof file.Copy !== "function") {
+    throw new Error(
+      `Host filesystem binding cannot move onto existing directory '${destination}': directory enumeration/copy is unavailable`
+    );
+  }
+  if (isPuertsReparsePoint(source) || isPuertsReparsePoint(destination)) {
+    throw new Error(
+      `Refusing to move '${source}' through a reparse point (symlink/junction); resolve the link or delete it first`
+    );
+  }
+  directory.CreateDirectory(destination);
+  for (const entry of Array.from(directory.GetFiles(source) ?? [])) {
+    const name = String(entry).replace(/\\/g, "/").split("/").pop();
+    file.Copy(String(entry), `${destination}/${name}`, true);
+  }
+  for (const subdir of Array.from(directory.GetDirectories(source) ?? [])) {
+    const name = String(subdir).replace(/\\/g, "/").split("/").pop();
+    if (isPuertsReparsePoint(String(subdir))) continue;
+    movePuertsDirectoryContents(String(subdir), `${destination}/${name}`);
+  }
+  for (const entry of Array.from(directory.GetFiles(source) ?? [])) {
+    try {
+      file.Delete(String(entry));
+    } catch {
+    }
+  }
+}
+var warnedMissingPuertsGetAttributes = false;
+function isPuertsReparsePoint(path) {
+  const file = CS.System.IO.File;
+  if (typeof file.GetAttributes !== "function") {
+    if (!warnedMissingPuertsGetAttributes) {
+      warnedMissingPuertsGetAttributes = true;
+      try {
+        console.warn(
+          "[platform] File.GetAttributes is unbound on this host; directory symlink checks are disabled (move/delete follow links)"
+        );
+      } catch {
+      }
+    }
+    return false;
+  }
+  try {
+    const attrs = file.GetAttributes(path);
+    const raw = typeof attrs === "number" ? attrs : attrs.value__;
+    const value = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(value)) return false;
+    return (value & 1024) !== 0;
+  } catch {
+    return false;
+  }
+}
+var warnedPuertsDeletionShells = false;
+function warnPuertsDeletionShellsOnce(path) {
+  if (warnedPuertsDeletionShells) return;
+  warnedPuertsDeletionShells = true;
+  try {
+    console.warn(
+      `[platform] Directory.Delete is unbound on this host; '${path}' contents were removed but empty directory shells cannot be deleted by this binding (logged once)`
+    );
+  } catch {
+  }
+}
+function deletePuertsDirectoryByEnumeration(path, recursive) {
+  const directory = CS.System.IO.Directory;
+  const file = CS.System.IO.File;
+  if (typeof directory.GetFiles !== "function" || typeof file.Delete !== "function") {
+    throw new Error(
+      `Host filesystem binding cannot delete directory '${path}': Directory.Delete and enumeration are unavailable`
+    );
+  }
+  if (isPuertsReparsePoint(path)) {
+    throw new Error(
+      `Refusing to delete '${path}' through a reparse point (symlink/junction); resolve the link or delete it directly`
+    );
+  }
+  const files = Array.from(directory.GetFiles(path) ?? []);
+  const subdirs = Array.from(directory.GetDirectories(path) ?? []);
+  if (!recursive) {
+    if (files.length > 0 || subdirs.length > 0) {
+      throw new Error(`Directory not empty: ${path}`);
+    }
+    return;
+  }
+  for (const entry of files) file.Delete(entry);
+  for (const subdir of subdirs) {
+    if (isPuertsReparsePoint(String(subdir))) continue;
+    deletePuertsDirectoryByEnumeration(String(subdir), true);
+  }
+  warnPuertsDeletionShellsOnce(path);
+}
 
 // ../../packages/platform/src/index.ts
 var fileSystemInstance = null;
@@ -2740,10 +3106,15 @@ function parseStreamingJson(partialJson) {
 }
 
 // ../../packages/ai/src/providers/simple-options.ts
+var DEFAULT_MAX_TOKENS = 32e3;
+function positiveFiniteOrInfinity(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : Number.POSITIVE_INFINITY;
+}
 function buildBaseOptions(model, options, apiKey) {
+  const modelMaxTokens = positiveFiniteOrInfinity(model.maxTokens);
   return {
     temperature: options?.temperature,
-    maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32e3),
+    maxTokens: options?.maxTokens || Math.min(modelMaxTokens, DEFAULT_MAX_TOKENS),
     signal: options?.signal,
     apiKey: apiKey || options?.apiKey,
     cacheRetention: options?.cacheRetention,
@@ -2765,11 +3136,18 @@ function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLeve
     medium: 8192,
     high: 16384
   };
-  const budgets = { ...defaultBudgets, ...customBudgets };
+  const budgets = { ...defaultBudgets };
+  if (customBudgets) {
+    for (const key of Object.keys(defaultBudgets)) {
+      const value = customBudgets[key];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) budgets[key] = value;
+    }
+  }
   const minOutputTokens = 1024;
   const level = clampReasoning(reasoningLevel);
-  let thinkingBudget = budgets[level];
-  const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+  let thinkingBudget = budgets[level] ?? defaultBudgets[level] ?? 0;
+  const outputCap = positiveFiniteOrInfinity(modelMaxTokens);
+  const maxTokens = Math.min(baseMaxTokens + thinkingBudget, outputCap);
   if (maxTokens <= thinkingBudget) {
     thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
   }
@@ -3695,7 +4073,11 @@ var streamOpenAICompletions = (model, context, options) => {
       }
       const emittedCallCounts = /* @__PURE__ */ new Map();
       const excessDuplicateEntries = /* @__PURE__ */ new Set();
+      const repeatExempt = new Set(
+        (context.tools ?? []).filter((tool) => tool.allowIdenticalRepeatCalls === true).map((tool) => tool.name)
+      );
       for (const entry of toolCallEntries) {
+        if (repeatExempt.has(entry.block.name)) continue;
         const key = `${entry.block.name}
 ${entry.partialArgs}`;
         const seen = (emittedCallCounts.get(key) ?? 0) + 1;
@@ -3734,8 +4116,11 @@ ${entry.partialArgs}`;
         block.arguments = parseFinalToolArguments(partialArgs, block.name);
         stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
       }
-      if (output.stopReason !== "error" && output.stopReason !== "aborted" && output.content.some((block) => block.type === "toolCall")) {
+      const hasToolCallBlocks = output.content.some((block) => block.type === "toolCall");
+      if (output.stopReason !== "error" && output.stopReason !== "aborted" && hasToolCallBlocks) {
         output.stopReason = "toolUse";
+      } else if (output.stopReason === "toolUse" && !hasToolCallBlocks) {
+        output.stopReason = "stop";
       }
       if (options?.signal?.aborted) {
         throw new Error("Request was aborted");
@@ -3767,8 +4152,18 @@ var streamSimpleOpenAICompletions = (model, context, options) => {
   }
   const base = buildBaseOptions(model, options, apiKey);
   const reasoningEffort = clampReasoning(options?.reasoning);
+  const needsThinkingAllowance = Boolean(model.reasoning) && options?.reasoning !== void 0;
+  const adjusted = needsThinkingAllowance ? adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options?.thinkingBudgets) : void 0;
+  let maxTokens = adjusted ? adjusted.maxTokens : base.maxTokens;
+  if (maxTokens === void 0) {
+    maxTokens = DEFAULT_MAX_TOKENS;
+  }
+  if (options?.maxTokens === void 0) {
+    maxTokens = Math.min(maxTokens, DEFAULT_MAX_TOKENS);
+  }
   return streamOpenAICompletions(model, context, {
     ...base,
+    maxTokens,
     reasoningEffort
   });
 };
@@ -7689,6 +8084,7 @@ export {
   type_exports,
   ExtendsUndefinedCheck,
   EventStream,
+  AssistantMessageEventStream,
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
   OPENAI_COMPAT_PROTOCOL_ERROR_CODE,