@cydm/pie 2.6.5 → 2.6.6

package/dist/chunks/{chunk-5OXH6NUH.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);
@@ -2750,6 +2998,17 @@ function isPuertsReparsePoint(path) {
     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;
@@ -2764,13 +3023,19 @@ function deletePuertsDirectoryByEnumeration(path, recursive) {
     );
   }
   const files = Array.from(directory.GetFiles(path) ?? []);
-  for (const entry of files) file.Delete(entry);
-  if (!recursive) return;
   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
@@ -2841,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,
@@ -2866,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);
   }
@@ -3796,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;
@@ -3871,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
   });
 };
@@ -7793,6 +8084,7 @@ export {
   type_exports,
   ExtendsUndefinedCheck,
   EventStream,
+  AssistantMessageEventStream,
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
   OPENAI_COMPAT_PROTOCOL_ERROR_CODE,