chainlesschain 0.166.114 → 0.166.117

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

@@ -56,6 +56,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";
@@ -4593,7 +4600,7 @@ export function editNotebookCell(notebookText, args = {}) {
   const out = (summary, cellId) => ({
     text: JSON.stringify(nb, null, 1) + "\n",
     summary,
-    cellId,
+    cellId: cellId ?? null,
   });
   const locate = () => {
     if (args.cell_id != null) {
@@ -5725,14 +5732,28 @@ async function executeToolInner(
     descriptor
       ? {
           name: descriptor.name,
-          kind: descriptor.kind || descriptor.category || descriptor.source,
-          category: descriptor.category,
+          kind:
+            descriptor.kind ||
+            descriptor.category ||
+            descriptor.telemetry?.category ||
+            descriptor.source ||
+            null,
+          category:
+            descriptor.category ??
+            descriptor.telemetry?.category ??
+            descriptor.kind ??
+            null,
         }
       : null;
   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"
@@ -7562,7 +7583,7 @@ async function executeToolInner(
               ? shellOutputPreview(err.stdout, "stdout", 16000)
               : {}),
             ...shellOutputPreview(err.stderr, "stderr", 4000),
-            exitCode: err.status,
+            exitCode: err.status ?? null,
             ...(typeof err.code === "string" && err.code
               ? {
                   policy: {
@@ -7697,8 +7718,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,
@@ -7707,11 +7728,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,
@@ -7725,7 +7748,7 @@ async function executeToolInner(
         });
       }
       return attachDescriptor({
-        stdout: String(res.stdout || "").substring(0, 30000),
+        ...shellOutputPreview(res.stdout, "stdout", 30000),
         exitCode: 0,
         command: normalizedCommand,
         readOnly,
@@ -8000,7 +8023,7 @@ async function executeToolInner(
           const available = discoverCommands(cwd).map((c) => ({
             name: c.name,
             scope: c.scope,
-            description: c.description || undefined,
+            ...(c.description ? { description: c.description } : {}),
           }));
           return attachDescriptor({
             error: `Unknown slash command "${head}".`,
@@ -8023,7 +8046,7 @@ async function executeToolInner(
           command: macro.name,
           scope: macro.scope,
           expandedPrompt: expanded,
-          warnings: warnings && warnings.length ? warnings : undefined,
+          ...(warnings?.length ? { warnings } : {}),
           instructions:
             "The expandedPrompt is the command's instructions. Carry them out " +
             "now using your normal tools.",
@@ -10301,7 +10324,7 @@ async function _executeRunCode(args, cwd) {
               error: `Invalid package name: "${packageName}"`,
               ...classified,
               language: lang,
-              scriptPath: persist ? scriptPath : undefined,
+              ...(persist ? { scriptPath } : {}),
             };
           }
 
@@ -10323,13 +10346,13 @@ async function _executeRunCode(args, cwd) {
               outcome: "disabled",
             });
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
-              exitCode: err.status,
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
+              exitCode: err.status ?? null,
               language: lang,
               ...classified,
               hint: autoInstallDisabledHint(packageName),
-              scriptPath: persist ? scriptPath : undefined,
+              ...(persist ? { scriptPath } : {}),
             };
           }
           if (!isPackageAllowed(packageName, installPolicy.allowlist)) {
@@ -10340,13 +10363,13 @@ async function _executeRunCode(args, cwd) {
               outcome: "blocked",
             });
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
-              exitCode: err.status,
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
+              exitCode: err.status ?? null,
               language: lang,
               ...classified,
               hint: `Package "${packageName}" is not in runCode.installAllowlist — install it manually or add it to the allowlist.`,
-              scriptPath: persist ? scriptPath : undefined,
+              ...(persist ? { scriptPath } : {}),
             };
           }
 
@@ -10396,13 +10419,13 @@ async function _executeRunCode(args, cwd) {
               ),
             );
             return {
-              error: (stderr || message).substring(0, 5000),
-              stderr: stderr.substring(0, 5000),
-              exitCode: err.status,
+              error: boundedCommandOutput(stderr || message, 5000),
+              stderr: boundedCommandOutput(stderr, 5000),
+              exitCode: err.status ?? null,
               language: lang,
               ...classified,
               hint: `Failed to auto-install "${packageName}". ${(installError.stderr || installError.message || "").substring(0, 500)}`,
-              scriptPath: persist ? scriptPath : undefined,
+              ...(persist ? { scriptPath } : {}),
             };
           };
 
@@ -10453,14 +10476,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],
-              scriptPath: persist ? scriptPath : undefined,
-            };
+              ...(persist ? { scriptPath } : {}),
+            });
           } catch (retryErr) {
             rethrowRunCodeSandboxFailure(retryErr);
             const retryStderr = (retryErr.stderr || "").toString();
@@ -10472,37 +10494,36 @@ async function _executeRunCode(args, cwd) {
               lang,
             );
             return {
-              error: (retryStderr || retryMessage).substring(0, 5000),
-              stderr: retryStderr.substring(0, 5000),
-              exitCode: retryErr.status,
+              error: boundedCommandOutput(retryStderr || retryMessage, 5000),
+              stderr: boundedCommandOutput(retryStderr, 5000),
+              exitCode: retryErr.status ?? null,
               language: lang,
               ...retryClassified,
               hint: `Package "${packageName}" was installed, but the script retry failed.`,
               autoInstalled: [packageName],
-              scriptPath: persist ? scriptPath : undefined,
+              ...(persist ? { scriptPath } : {}),
             };
           }
         }
       }
 
       return {
-        error: (stderr || message).substring(0, 5000),
-        stderr: stderr.substring(0, 5000),
-        exitCode: err.status,
+        error: boundedCommandOutput(stderr || message, 5000),
+        stderr: boundedCommandOutput(stderr, 5000),
+        exitCode: err.status ?? null,
         language: lang,
         ...classified,
-        scriptPath: persist ? scriptPath : undefined,
+        ...(persist ? { scriptPath } : {}),
       };
     }
 
     const duration = Date.now() - start;
-    return {
+    return Object.assign(boundedCodeOutput(output), {
       success: true,
-      ...boundedCodeOutput(output),
       language: lang,
       duration: `${duration}ms`,
-      scriptPath: persist ? scriptPath : undefined,
-    };
+      ...(persist ? { scriptPath } : {}),
+    });
   } finally {
     // Only clean up if not persisting
     if (!persist) {
@@ -10537,14 +10558,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;
 
@@ -10560,47 +10576,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 &&