chainlesschain 0.166.115 → 0.166.118

package/src/lib/tool-result-preview.js

@@ -0,0 +1,276 @@
+import {
+  createEvidenceJsonTextBoundary,
+  AGENT_CODE_TEXT_RESULT_TOOLS,
+} from "./evolution/evidence-json-text.js";
+import { createHash } from "node:crypto";
+
+// Keep host identity outside the JSON evidence object. External JSON results
+// cannot nominate a digest or borrow an earlier command's output identity.
+const HOST_OUTPUT_IDENTITIES = new WeakMap();
+export function registerHostToolOutput(result, output) {
+  HOST_OUTPUT_IDENTITIES.set(
+    result,
+    Object.freeze({
+      chars: output.length,
+      digest: createHash("sha256").update(output).digest("hex"),
+      visibleOutput: result.output,
+    }),
+  );
+  return result;
+}
+export function copyHostToolOutputIdentity(result, source) {
+  const identity = HOST_OUTPUT_IDENTITIES.get(source);
+  if (identity) HOST_OUTPUT_IDENTITIES.set(result, identity);
+  return result;
+}
+export function hostToolOutputIdentity(result) {
+  const identity = HOST_OUTPUT_IDENTITIES.get(result);
+  return identity?.visibleOutput === result?.output ? identity : undefined;
+}
+
+const PREVIEW_HINT =
+  "Tool output truncated. Narrow the request: filter/count locally, select fields, search_files, or read_file with offset/limit. Omitted text is not full-output evidence.";
+
+/** Check only host-created excerpts; original uncut tool text still reaches ingress. */
+function completeExcerpt(text, tool) {
+  const scan = createEvidenceJsonTextBoundary((message) => new Error(message));
+  const visit = (value, layer) => {
+    if (typeof value === "string") return project(value, layer);
+    if (Array.isArray(value)) return value.map((child) => visit(child, layer));
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, child]) => [key, visit(child, layer)]),
+      );
+    }
+    return value;
+  };
+  const project = (value, layer = 0) =>
+    scan(value, {
+      layer,
+      codeText: AGENT_CODE_TEXT_RESULT_TOOLS.includes(tool),
+      visit,
+      plain: (plain) => plain,
+      equal: (left, right) => JSON.stringify(left) === JSON.stringify(right),
+    });
+  try {
+    project(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function omitted(chars) {
+  return `Text omitted (${chars} chars); narrow the request to inspect a complete value.`;
+}
+
+const STATUS_KEYS = new Set([
+  "success",
+  "error",
+  "exitCode",
+  "status",
+  "code",
+  "signal",
+  "path",
+  "range",
+  "nextRead",
+  "duration",
+  "language",
+]);
+
+// Native JSON.parse is used only after checking its lossy cases: duplicate
+// decoded keys and non-finite/unsafe numbers must never turn into a safe-looking
+// preview. This pass does not repair syntax or decode text leaves.
+function parsePreviewJson(text) {
+  const value = JSON.parse(text);
+  const stack = [];
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (char === '"') {
+      const start = index;
+      while (++index < text.length) {
+        if (text[index] === "\\") index++;
+        else if (text[index] === '"') break;
+      }
+      const object = stack.at(-1);
+      if (object?.key) {
+        const key = JSON.parse(text.slice(start, index + 1));
+        if (object.keys.has(key)) throw new TypeError("Ambiguous JSON keys");
+        object.keys.add(key);
+        object.key = false;
+      }
+    } else if (char === "{") stack.push({ keys: new Set(), key: true });
+    else if (char === "[") stack.push(null);
+    else if (char === "}" || char === "]") stack.pop();
+    else if (char === "," && stack.at(-1)) stack.at(-1).key = true;
+    else if (/[\d-]/u.test(char)) {
+      const token = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(
+        text.slice(index),
+      )[0];
+      const number = Number(token);
+      if (
+        !Number.isFinite(number) ||
+        (Number.isInteger(number) && !Number.isSafeInteger(number))
+      )
+        throw new TypeError("Unsafe JSON number");
+      index += token.length - 1;
+    }
+  }
+  return value;
+}
+
+/** Produce complete JSON values, never prefixes of a JSON leaf. */
+export function boundedToolResultText(text, max) {
+  if (text.length <= max) return text;
+  let original;
+  try {
+    original = parsePreviewJson(text);
+  } catch {
+    // Plain output can retain a prefix only when it cannot contain a sliced
+    // structured span. In particular, do not hide broken JSON in a preview.
+    if (!/[{}\[\]"']/u.test(text)) {
+      const marker = `\nTool output truncated (${text.length} chars). Narrow the request.`;
+      if (marker.length < max) {
+        let end = max - marker.length;
+        if (/[\uD800-\uDBFF]/u.test(text[end - 1] ?? "")) end--;
+        return text.slice(0, end) + marker;
+      }
+    }
+    original = omitted(text.length);
+  }
+
+  for (const limit of [8192, 2048, 512, 128, 0]) {
+    let nodes = 0;
+    const preview = (value, depth = 0) => {
+      if (++nodes > 128 || depth > 6)
+        return "Value omitted; select a smaller subtree.";
+      if (typeof value === "string")
+        return JSON.stringify(value).length > limit
+          ? omitted(value.length)
+          : value;
+      if (!value || typeof value !== "object") return value;
+      if (Array.isArray(value)) {
+        const kept = [];
+        for (const child of value) {
+          if (kept.length >= 32 || nodes >= 128) break;
+          kept.push(preview(child, depth + 1));
+        }
+        if (kept.length < value.length)
+          kept.push(
+            `Items omitted (${value.length - kept.length}); narrow the request.`,
+          );
+        return kept;
+      }
+      const kept = Object.create(null);
+      const entries = Object.entries(value).sort(
+        ([a], [b]) => Number(STATUS_KEYS.has(b)) - Number(STATUS_KEYS.has(a)),
+      );
+      let count = 0;
+      for (const [key, child] of entries) {
+        if (count >= 32 || nodes >= 128) break;
+        if (key.length > 256) continue;
+        Object.defineProperty(kept, key, {
+          enumerable: true,
+          value: preview(child, depth + 1),
+        });
+        count++;
+      }
+      if (count < entries.length) {
+        let marker = "_omittedFields";
+        while (Object.hasOwn(kept, marker)) marker += "_";
+        Object.defineProperty(kept, marker, {
+          enumerable: true,
+          value: entries.length - count,
+        });
+      }
+      return kept;
+    };
+    const value = preview(original);
+    const result =
+      value && !Array.isArray(value) && typeof value === "object"
+        ? value
+        : { preview: value };
+    let marker = "_toolOutputPreview";
+    while (Object.hasOwn(result, marker)) marker += "_";
+    Object.defineProperty(result, marker, {
+      enumerable: true,
+      value: {
+        truncated: true,
+        originalChars: text.length,
+        hint: PREVIEW_HINT,
+      },
+    });
+    const serialized = JSON.stringify(result);
+    if (serialized.length <= max) return serialized;
+  }
+  const summary = JSON.stringify({
+    truncated: true,
+    originalChars: text.length,
+    hint: PREVIEW_HINT,
+  });
+  if (summary.length <= max) return summary;
+  if (max >= 18) return '{"truncated":true}';
+  return max >= 4 ? "null" : max >= 2 ? "{}" : "0";
+}
+
+/** Keep cursors/status, but remove JSON fragments created by host paging. */
+export function safeHostToolResultForModel(tool, result) {
+  if (!result || typeof result !== "object" || Array.isArray(result))
+    return result;
+  const fields = [];
+  if (
+    tool === "read_file" &&
+    (result.truncated || result.range || result.nextRead)
+  )
+    fields.push("content");
+  if (tool === "run_code" && result.truncated) fields.push("output");
+  if (tool === "check_shell") fields.push("stdout", "stderr");
+  if (tool === "run_shell" || tool === "git") {
+    for (const field of ["stdout", "stderr"])
+      if (result[`${field}_truncated`])
+        fields.push(field, `${field}_diagnostics`);
+  }
+  let safe = result;
+  for (const field of fields) {
+    const text = result[field];
+    if (typeof text !== "string" || completeExcerpt(text, tool)) continue;
+    if (safe === result) safe = { ...result };
+    safe[field] = omitted(text.length);
+    safe[`${field}Omitted`] = true;
+    safe[`${field}OmittedChars`] = text.length;
+  }
+  return safe;
+}
+
+/** Prefer a whole JSON tree over slicing stdout through an embedded value. */
+export function boundedCommandOutput(output, max, tool = "run_code") {
+  const encoded = JSON.stringify(output);
+  if (encoded.length <= max) return output;
+  // If stdout itself is JSON, preview that tree rather than its quoted form.
+  let json = false;
+  try {
+    parsePreviewJson(output);
+    json = true;
+  } catch {
+    /* Plain command text. */
+  }
+  if (json) {
+    const preview = boundedToolResultText(
+      output,
+      Math.max(1, Math.floor(max / 2)),
+    );
+    if (JSON.stringify(preview).length <= max && completeExcerpt(preview, tool))
+      return preview;
+  } else if (!/[{}\[\]"']/u.test(output)) {
+    let low = 0;
+    let high = Math.min(output.length, max);
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      if (JSON.stringify(output.slice(0, middle)).length <= max) low = middle;
+      else high = middle - 1;
+    }
+    if (/[\uD800-\uDBFF]/u.test(output[low - 1] ?? "")) low--;
+    return output.slice(0, low);
+  }
+  return omitted(output.length);
+}

package/src/runtime/agent-core.js

@@ -4,6 +4,7 @@ import {
 } from "../lib/formal-budget-provider-scope.js";
 import { isFormalBudgetError } from "../lib/formal-budget-errors.js";
 import { normalizeOllamaBaseUrl } from "../lib/ollama-base-url.js";
+import { ollamaProviderFetch } from "../lib/ollama-provider-fetch.js";
 import {
   normalizeProviderBaseUrl,
   openAICompatibleBaseUrl,
@@ -56,6 +57,13 @@ import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
 const READ_FILE_REQUEST_CONTEXT = Symbol("read-file-request-context");
 import { gitToolInputError } from "../lib/git-tool-input.js";
 import { shellOutputPage, shellOutputPreview } from "../lib/shell-output.js";
+import {
+  boundedToolResultText,
+  boundedCommandOutput,
+  safeHostToolResultForModel,
+  registerHostToolOutput,
+  copyHostToolOutputIdentity,
+} from "../lib/tool-result-preview.js";
 import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "../lib/diagnostic-workflow.js";
 import { CODING_TASK_QUALITY_GUIDANCE } from "../lib/coding-task-guidance.js";
 import { RemoteReadLoopGuard } from "../lib/remote-read-loop-guard.js";
@@ -5741,7 +5749,12 @@ async function executeToolInner(
   const descriptorPayload = buildPayload(runtimeDescriptor);
   const attachDescriptor = (payload, overrideDescriptor = null) => {
     const descriptor = buildPayload(overrideDescriptor || runtimeDescriptor);
-    return descriptor ? { ...payload, toolDescriptor: descriptor } : payload;
+    return descriptor
+      ? copyHostToolOutputIdentity(
+          { ...payload, toolDescriptor: descriptor },
+          payload,
+        )
+      : payload;
   };
   const localToolExecutor =
     externalToolExecutors && typeof externalToolExecutors === "object"
@@ -7706,8 +7719,8 @@ async function executeToolInner(
       ) {
         return attachDescriptor({
           success: true,
-          stdout: String(res.stdout || "").substring(0, 30000),
-          stderr: String(res.stderr || "").substring(0, 2000),
+          ...shellOutputPreview(res.stdout, "stdout", 30000),
+          ...shellOutputPreview(res.stderr, "stderr", 2000),
           exitCode: res.status,
           command: normalizedCommand,
           readOnly: true,
@@ -7716,11 +7729,13 @@ async function executeToolInner(
         });
       }
       if (res.status !== 0) {
-        const stderr = String(res.stderr || "").substring(0, 2000);
+        const stderr = String(res.stderr || "");
         return attachDescriptor({
-          error: stderr || `git exited with code ${res.status}`,
-          stdout: String(res.stdout || "").substring(0, 30000),
-          stderr,
+          error:
+            boundedCommandOutput(stderr, 2000) ||
+            `git exited with code ${res.status}`,
+          ...shellOutputPreview(res.stdout, "stdout", 30000),
+          ...shellOutputPreview(stderr, "stderr", 2000),
           exitCode: res.status,
           command: normalizedCommand,
           readOnly,
@@ -7734,7 +7749,7 @@ async function executeToolInner(
         });
       }
       return attachDescriptor({
-        stdout: String(res.stdout || "").substring(0, 30000),
+        ...shellOutputPreview(res.stdout, "stdout", 30000),
         exitCode: 0,
         command: normalizedCommand,
         readOnly,
@@ -10332,8 +10347,8 @@ async function _executeRunCode(args, cwd) {
               outcome: "disabled",
             });
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
               exitCode: err.status ?? null,
               language: lang,
               ...classified,
@@ -10349,8 +10364,8 @@ async function _executeRunCode(args, cwd) {
               outcome: "blocked",
             });
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
               exitCode: err.status ?? null,
               language: lang,
               ...classified,
@@ -10405,8 +10420,8 @@ async function _executeRunCode(args, cwd) {
               ),
             );
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
               exitCode: err.status ?? null,
               language: lang,
               ...classified,
@@ -10462,14 +10477,13 @@ async function _executeRunCode(args, cwd) {
             );
             const retryDuration = Date.now() - retryStart;
 
-            return {
+            return Object.assign(boundedCodeOutput(retryOutput), {
               success: true,
-              ...boundedCodeOutput(retryOutput),
               language: lang,
               duration: `${retryDuration}ms`,
               autoInstalled: [packageName],
               ...(persist ? { scriptPath } : {}),
-            };
+            });
           } catch (retryErr) {
             rethrowRunCodeSandboxFailure(retryErr);
             const retryStderr = (retryErr.stderr || "").toString();
@@ -10481,8 +10495,8 @@ async function _executeRunCode(args, cwd) {
               lang,
             );
             return {
-              error: (retryStderr || retryMessage).substring(0, 5000),
-              stderr: retryStderr.substring(0, 5000),
+              error: boundedCommandOutput(retryStderr || retryMessage, 5000),
+              stderr: boundedCommandOutput(retryStderr, 5000),
               exitCode: retryErr.status ?? null,
               language: lang,
               ...retryClassified,
@@ -10495,8 +10509,8 @@ async function _executeRunCode(args, cwd) {
       }
 
       return {
-        error: (stderr || message).substring(0, 5000),
-        stderr: stderr.substring(0, 5000),
+        error: boundedCommandOutput(stderr || message, 5000),
+        stderr: boundedCommandOutput(stderr, 5000),
         exitCode: err.status ?? null,
         language: lang,
         ...classified,
@@ -10505,13 +10519,12 @@ async function _executeRunCode(args, cwd) {
     }
 
     const duration = Date.now() - start;
-    return {
+    return Object.assign(boundedCodeOutput(output), {
       success: true,
-      ...boundedCodeOutput(output),
       language: lang,
       duration: `${duration}ms`,
       ...(persist ? { scriptPath } : {}),
-    };
+    });
   } finally {
     // Only clean up if not persisting
     if (!persist) {
@@ -10546,14 +10559,9 @@ export const MAX_SUB_AGENT_DEPTH = 5;
 export const MAX_SUB_AGENTS_PER_RUN = 32;
 
 /**
- * Per-tool-result character cap fed back to the model. One giant tool output (a
- * huge file, a verbose command, an MCP blob) must not blow the context window —
- * but the model is TOLD when output is cut, instead of the old silent
- * `substring(0, 5000)` that sliced mid-content with no marker and undercut even
- * read_file's own 50k self-limit. Tools that self-limit (read_file, notebook
- * render) stay below this; it is the final safety net for the ones that don't
- * (run_shell, search_files, run_code, MCP). CC_MAX_TOOL_RESULT_CHARS may only
- * tighten the host ceiling; it cannot raise or disable it.
+ * Total character cap fed back to the model, including truncation metadata.
+ * Complete JSON previews retain status and small fields while omitting large
+ * leaves. CC_MAX_TOOL_RESULT_CHARS may only tighten the host ceiling.
  */
 export const MAX_TOOL_RESULT_CHARS_HARD_LIMIT = 50000;
 
@@ -10569,47 +10577,38 @@ export const MAX_TOOL_RESULT_CHARS = resolveMaxToolResultChars(
 );
 
 /**
- * Cap a serialized tool result to `max` chars, appending a visible truncation
- * marker (with the original length + how to get the rest) when it overflows —
- * so the model never silently receives a mid-content slice. Pure; exported for
- * tests.
+ * Cap a serialized tool result without splitting JSON values. Plain prefixes
+ * are allowed only when they cannot contain a truncated structured span.
  */
 export function capToolResultString(serialized, max = MAX_TOOL_RESULT_CHARS) {
   const s = String(serialized ?? "");
   const effectiveMax = resolveMaxToolResultChars(max);
-  if (s.length <= effectiveMax) return s;
-  return (
-    s.slice(0, effectiveMax) +
-    `\n…[tool output truncated: showing the first ${effectiveMax} of ${s.length} chars` +
-    ` — narrow the request (read a line range, grep, or paginate) to see the rest]`
-  );
+  return boundedToolResultText(s, effectiveMax);
 }
 
 /** Leave room for JSON escaping and execution metadata, including the hint. */
 export function boundedCodeOutput(value) {
   const output = String(value ?? "");
   const budget = Math.max(0, MAX_TOOL_RESULT_CHARS - 4096);
-  let low = 0;
-  let high = Math.min(output.length, 50000);
-  while (low < high) {
-    const mid = Math.ceil((low + high) / 2);
-    if (JSON.stringify(output.slice(0, mid)).length <= budget) low = mid;
-    else high = mid - 1;
-  }
-  if (low === output.length) return { output };
-  if (low > 0 && /[\uD800-\uDBFF]/.test(output[low - 1])) low--;
-  return {
-    truncated: true,
-    outputChars: output.length,
-    returnedChars: low,
-    hint: "Only an output prefix is shown. Do not rerun the same full-file print: filter/count locally and print a bounded summary with source line numbers, or use read_file with offset/limit for a missing section. This prefix is not evidence of the entire file.",
-    output: output.slice(0, low),
-  };
+  if (JSON.stringify(output).length <= budget) return { output };
+  const preview = boundedCommandOutput(output, Math.max(1, budget));
+  return registerHostToolOutput(
+    {
+      truncated: true,
+      outputChars: output.length,
+      returnedChars: preview.length,
+      hint: "Output is incomplete. Do not rerun the same full-file print: filter/count locally and print a bounded summary with source line numbers, or use read_file with offset/limit for a missing section. Omitted text is not evidence of the entire file.",
+      output: preview,
+    },
+    output,
+  );
 }
 
 /** Avoid injecting the same file page twice while its original is still visible. */
 export function toolResultForModel(tool, result, messages) {
-  const serialized = capToolResultString(safeStringifyToolResult(result));
+  const serialized = capToolResultString(
+    safeStringifyToolResult(safeHostToolResultForModel(tool, result)),
+  );
   if (
     (tool === "run_code" || tool === "run_shell") &&
     !result?.error &&
@@ -12215,7 +12214,7 @@ export async function chatWithTools(rawMessages, options) {
         },
       );
     }
-    const response = await providerFetch(apiUrl, {
+    const response = await ollamaProviderFetch(apiUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       signal,
@@ -12624,7 +12623,12 @@ export async function chatWithTools(rawMessages, options) {
     throw new TypeError("Invalid API response: unsupported assistant message");
   }
   // Provider reasoning text is not part of the governed replay protocol.
-  const message = { role: "assistant", content: providerMessage.content };
+  // Tool-only responses may omit content. Keep the live message JSON-safe for
+  // canonical tool-round settlement instead of introducing an undefined field.
+  const message = {
+    role: "assistant",
+    content: providerMessage.content ?? null,
+  };
   if (Object.hasOwn(providerMessage, "tool_calls")) {
     message.tool_calls = providerMessage.tool_calls;
   }
@@ -13055,7 +13059,7 @@ async function _chatOllamaStreaming(
   stallMs,
   stallTimeoutMs,
 ) {
-  const response = await providerFetch(apiUrl, {
+  const response = await ollamaProviderFetch(apiUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     signal,
@@ -15284,38 +15288,53 @@ export async function* agentLoop(messages, options) {
         typeof options.runtimeResultRetention === "object"
           ? options.runtimeResultRetention
           : options.runtimeResultRetentionOptions;
-      const retained = releaseOldLiveSessionResults(messages, retentionConfig);
+      const candidate = releaseOldLiveSessionResults(messages, retentionConfig);
       if (
-        retained.stats.released > 0 &&
-        !_sameMessageSnapshot(retained.messages, messages)
+        candidate.stats.released > 0 &&
+        !_sameMessageSnapshot(candidate.messages, messages)
       ) {
-        const authorityExpectedMessages = [...messages];
-        const liveExpectedMessages = [...messages];
-        try {
-          await _settleAutomaticCompaction({
-            messages,
-            liveExpectedMessages,
-            authorityExpectedMessages,
-            compacted: retained.messages,
-            stats: retained.stats,
-            options,
-            trigger: "runtime-retention",
-          });
-          yield {
-            type: "session-runtime-retention",
-            runId,
-            stats: retained.stats,
-          };
-        } catch (error) {
-          yield {
-            type: "session-runtime-retention-degraded",
-            runId,
-            reason:
-              error?.code === "SESSION_REVISION_STALE"
-                ? "session_messages_changed_during_retention"
-                : "canonical_retention_settlement_failed",
-            code: error?.code || "CC_SESSION_RETENTION_SETTLEMENT_FAILED",
-          };
+        // Complete tool effects must be durable before a retention checkpoint
+        // can compare against them. Let a host settlement failure propagate
+        // before another provider call, just as semantic compaction does.
+        options.onBeforeCompaction?.();
+        // The host hook may update live context. Derive both the candidate and
+        // the expected snapshots from the state after that boundary.
+        const retained = releaseOldLiveSessionResults(
+          messages,
+          retentionConfig,
+        );
+        if (
+          retained.stats.released > 0 &&
+          !_sameMessageSnapshot(retained.messages, messages)
+        ) {
+          const authorityExpectedMessages = [...messages];
+          const liveExpectedMessages = [...messages];
+          try {
+            await _settleAutomaticCompaction({
+              messages,
+              liveExpectedMessages,
+              authorityExpectedMessages,
+              compacted: retained.messages,
+              stats: retained.stats,
+              options,
+              trigger: "runtime-retention",
+            });
+            yield {
+              type: "session-runtime-retention",
+              runId,
+              stats: retained.stats,
+            };
+          } catch (error) {
+            yield {
+              type: "session-runtime-retention-degraded",
+              runId,
+              reason:
+                error?.code === "SESSION_REVISION_STALE"
+                  ? "session_messages_changed_during_retention"
+                  : "canonical_retention_settlement_failed",
+              code: error?.code || "CC_SESSION_RETENTION_SETTLEMENT_FAILED",
+            };
+          }
         }
       }
     }