chainlesschain 0.166.115 → 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";
@@ -5741,7 +5748,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 +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,
@@ -7716,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,
@@ -7734,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,
@@ -10332,8 +10346,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 +10363,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 +10419,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 +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],
               ...(persist ? { scriptPath } : {}),
-            };
+            });
           } catch (retryErr) {
             rethrowRunCodeSandboxFailure(retryErr);
             const retryStderr = (retryErr.stderr || "").toString();
@@ -10481,8 +10494,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 +10508,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 +10518,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 +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;
 
@@ -10569,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 &&

package/src/runtime/headless-stream.js

@@ -3826,6 +3826,21 @@ async function runAgentHeadlessStreamInWorkspace(
       return false;
     }
   };
+  const repairAndSettleToolRoundsForHost = (phase) => {
+    const originalMessages = new Set(messages);
+    const balanced = sanitizeToolPairs(messages);
+    for (const message of balanced) {
+      if (
+        !originalMessages.has(message) &&
+        message.role === "assistant" &&
+        !message.tool_calls?.length
+      )
+        markRuntimeOnlySessionMessage(message);
+    }
+    messages.length = 0;
+    messages.push(...balanced);
+    return settleToolRoundsForHost(phase);
+  };
   const loopOptionsBase = {
     ...(evolutionIngress === null ? {} : { evolutionIngress }),
     model,
@@ -5637,6 +5652,12 @@ async function runAgentHeadlessStreamInWorkspace(
       const turnWasAborted = currentAbort?.signal.aborted === true;
       currentAbort = null;
       if (err?.code === AGENT_EVOLUTION_INGRESS_FAILED_CODE) {
+        evolutionIngressFailed = true;
+        // Ingress can reject the next model request after a tool round has
+        // already completed. Keep those completed effects in the canonical
+        // session before terminating this Run; incomplete calls are removed
+        // with the same pairing repair used for an interrupted turn.
+        if (!repairAndSettleToolRoundsForHost("after-model")) break;
         emit({
           type: "result",
           subtype: "error_evolution_ingress",
@@ -5646,7 +5667,6 @@ async function runAgentHeadlessStreamInWorkspace(
           turn: turns,
         });
         sawError = true;
-        evolutionIngressFailed = true;
         break;
       }
       if (persist) {
@@ -5677,6 +5697,7 @@ async function runAgentHeadlessStreamInWorkspace(
           break;
         }
         if (err?.runtimeLedgerPersistence === true) {
+          if (!repairAndSettleToolRoundsForHost("after-model")) break;
           emit({
             type: "result",
             subtype: "error_persistence",
@@ -5693,6 +5714,7 @@ async function runAgentHeadlessStreamInWorkspace(
         err?.code === "CC_SESSION_BUDGET_USAGE_UNKNOWN" ||
         options.sessionBudget?.signal?.aborted === true
       ) {
+        if (!repairAndSettleToolRoundsForHost("after-model")) break;
         const budgetReason =
           options.sessionBudget?.reason?.() ||
           err.budgetReason ||
@@ -5729,21 +5751,7 @@ async function runAgentHeadlessStreamInWorkspace(
         // the array length unchanged. sanitizeToolPairs is idempotent on an
         // already-balanced array and leaves user/text turns untouched, so the
         // intentional dangling-user state above is preserved.
-        const originalMessages = new Set(messages);
-        const balanced = sanitizeToolPairs(messages);
-        // Only the sanitizer's newly-created commentary for discarded calls
-        // is ephemeral. Existing real messages retain their authority.
-        for (const message of balanced) {
-          if (
-            !originalMessages.has(message) &&
-            message.role === "assistant" &&
-            !message.tool_calls?.length
-          )
-            markRuntimeOnlySessionMessage(message);
-        }
-        messages.length = 0;
-        messages.push(...balanced);
-        if (!settleToolRoundsForHost("after-model")) break;
+        if (!repairAndSettleToolRoundsForHost("after-model")) break;
         emit({
           type: "result",
           subtype: "interrupted",
@@ -5754,7 +5762,12 @@ async function runAgentHeadlessStreamInWorkspace(
         });
         continue;
       }
-      if (isAbort) break; // outer options.signal — caller is shutting down
+      if (isAbort) {
+        // Caller shutdown terminates the stream, but completed tool effects
+        // from the in-flight turn still belong in the durable transcript.
+        if (!repairAndSettleToolRoundsForHost("after-model")) break;
+        break;
+      }
       if (!settleToolRoundsForHost("after-model")) break;
       const transportDetails = transportErrorDetails(err);
       emit({
@@ -5771,6 +5784,7 @@ async function runAgentHeadlessStreamInWorkspace(
       persistTurnBindingLog();
     }
     if (turnBindingPersistenceError) {
+      if (!repairAndSettleToolRoundsForHost("after-model")) break;
       emitTurnBindingFailure();
       sawError = true;
       break;
@@ -5792,6 +5806,7 @@ async function runAgentHeadlessStreamInWorkspace(
     }
 
     if (outcome.endReason === "compaction-usage-unknown") {
+      if (!repairAndSettleToolRoundsForHost("after-model")) break;
       sawError = true;
       emit({
         type: "result",

package/src/assets/web-panel/assets/MarkdownRenderer-D8_iZief.js

@@ -1 +0,0 @@
-import{P as c,J as p,b as a}from"./vendor-Bn1JzzAn.js";import{r as s}from"./markdown-Yo_c6Krv.js";import{_ as d}from"./index-Bhf-MuUh.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=a(()=>s(e.content||"")),n={props:e,rendered:r,computed:a,get renderMarkdown(){return s}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function m(t,o,e,r,n,u){return c(),p("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const w=d(_,[["render",m],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-jIIa0G/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{w as M};