ucode-agent 1.62.0 → 1.62.2

package/src/core/openable.js

@@ -0,0 +1,174 @@
+/**
+ * openable.js — a page that works when you double-click it.
+ *
+ * ucode hands a plain app over as a file:// link, and the plain starter loads
+ * its code with <script type="module">. Browsers refuse module scripts from
+ * file:// (CORS, origin 'null'), so the page drew its markup and ran none of
+ * its JavaScript: every button dead, nothing in the console the user would
+ * ever open. The check never saw it, because it serves the folder over http.
+ *
+ * So before the check, each local module script is rewritten into one
+ * ordinary deferred script: the files it imports are inlined into it, and the
+ * whole program is wrapped in a function, which keeps a module's private
+ * scope and strict mode. Anything this cannot do faithfully — an import from
+ * a URL or a package, a cycle, `export ... from`, import.meta — is left as it
+ * was.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { parse } from '@babel/parser';
+import { writeTracked } from '../tools/shared.js';
+
+const SCRIPT = /<script\b([^>]*)>\s*<\/script>/gi;
+const attr = (attrs, name) => new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(attrs);
+const valueOf = (m) => m && (m[1] ?? m[2] ?? m[3]);
+const LOCAL_SRC = (src) => src && !/^(?:[a-z]+:|\/\/)/i.test(src);
+
+class Skip extends Error {}
+
+/** Rewrite every local module script in dir/<file>. Returns the scripts changed. */
+export async function makeOpenable(dir, file = 'index.html') {
+  const html = path.join(dir, file);
+  const page = await fs.readFile(html, 'utf8').catch(() => null);
+  if (page === null) return [];
+
+  const changed = [];
+  const tags = [];
+  for (const m of page.matchAll(SCRIPT)) {
+    const src = valueOf(attr(m[1], 'src'));
+    if (valueOf(attr(m[1], 'type'))?.toLowerCase() === 'module' && LOCAL_SRC(src)) tags.push({ tag: m[0], attrs: m[1], src });
+  }
+  let next = page;
+  const done = new Set(); // the same script twice on a page is rewritten once
+  for (const { tag, attrs, src } of tags) {
+    const entry = path.resolve(dir, src.split(/[?#]/)[0]);
+    if (!done.has(entry)) {
+      let code;
+      try {
+        code = await bundle(entry);
+      } catch (err) {
+        if (err instanceof Skip || err?.code === 'ENOENT' || err instanceof SyntaxError) continue;
+        throw err;
+      }
+      await writeTracked(entry, code);
+      done.add(entry);
+    }
+    let classic = attrs.replace(/\s*\btype\s*=\s*(?:"module"|'module'|module)/i, '');
+    if (!/\bdefer\b/i.test(classic)) classic += ' defer';
+    next = next.replace(tag, () => `<script${classic}></script>`);
+    changed.push(src);
+  }
+  if (next !== page) await writeTracked(html, next);
+  return changed;
+}
+
+/** The entry and everything it imports, as one classic script. */
+async function bundle(entry) {
+  const order = [];
+  const seen = new Map(); // file -> 'visiting' | module
+  const visit = async (file) => {
+    if (seen.get(file) === 'visiting') throw new Skip('import cycle');
+    if (seen.has(file)) return seen.get(file);
+    seen.set(file, 'visiting');
+    const mod = await transform(file, file !== entry, visit);
+    seen.set(file, mod);
+    order.push(mod);
+    return mod;
+  };
+  const main = await visit(entry);
+  const deps = order.filter((m) => m !== main);
+
+  const body = [
+    ...deps.map((m) => `// ${path.relative(path.dirname(entry), m.file).split(path.sep).join('/')}\nconst ${m.name} = (() => {\n${m.code}\n})();\n`),
+    main.code,
+  ].join('\n');
+  return '// Rewritten by ucode as one ordinary script, so the page runs when opened\n' +
+    '// straight from disk (browsers block module scripts on file://).\n' +
+    `(${main.tla ? 'async ' : ''}() => {\n'use strict';\n${body}\n})();\n`;
+}
+
+let ids = 0;
+
+/** One module: imports become reads of earlier modules, exports are stripped (and returned, for a dependency). */
+async function transform(file, isDep, visit) {
+  const src = await fs.readFile(file, 'utf8');
+  const ast = parse(src, { sourceType: 'module', allowAwaitOutsideFunction: true });
+  const edits = [];
+  const exported = []; // [exportedName, localName]
+  const names = (id) => {
+    if (id.type !== 'Identifier') throw new Skip('destructured export');
+    return id.name;
+  };
+
+  for (const node of ast.program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const spec = node.source.value;
+      if (!/^\.{1,2}\//.test(spec)) throw new Skip(`import from ${spec}`);
+      const dep = await visit(path.resolve(path.dirname(file), spec.split(/[?#]/)[0]));
+      const parts = [];
+      const named = [];
+      for (const s of node.specifiers) {
+        if (s.type === 'ImportDefaultSpecifier') parts.push(`const ${s.local.name} = ${dep.name}.default;`);
+        else if (s.type === 'ImportNamespaceSpecifier') parts.push(`const ${s.local.name} = ${dep.name};`);
+        else {
+          const imported = s.imported.name ?? s.imported.value;
+          named.push(imported === s.local.name ? imported : `${JSON.stringify(imported)}: ${s.local.name}`);
+        }
+      }
+      if (named.length) parts.unshift(`const { ${named.join(', ')} } = ${dep.name};`);
+      edits.push([node.start, node.end, parts.join(' ')]);
+    } else if (node.type === 'ExportNamedDeclaration') {
+      if (node.source) throw new Skip('export from');
+      if (node.declaration) {
+        const d = node.declaration;
+        if (d.type === 'VariableDeclaration') for (const v of d.declarations) exported.push([names(v.id), names(v.id)]);
+        else exported.push([d.id.name, d.id.name]);
+        edits.push([node.start, d.start, '']);
+      } else {
+        for (const s of node.specifiers) exported.push([s.exported.name ?? s.exported.value, s.local.name]);
+        edits.push([node.start, node.end, '']);
+      }
+    } else if (node.type === 'ExportDefaultDeclaration') {
+      const d = node.declaration;
+      if ((d.type === 'FunctionDeclaration' || d.type === 'ClassDeclaration') && d.id) {
+        exported.push(['default', d.id.name]);
+        edits.push([node.start, d.start, '']);
+      } else {
+        exported.push(['default', '__default']);
+        edits.push([node.start, d.start, 'const __default = ']);
+      }
+    } else if (node.type === 'ExportAllDeclaration') {
+      throw new Skip('export *');
+    }
+  }
+  const moduleOnly = (n) => n.type === 'Import' || n.type === 'ImportExpression' || (n.type === 'MetaProperty' && n.meta.name === 'import');
+  if (some(ast.program, moduleOnly, false)) throw new Skip('import.meta or import()');
+
+  let code = src;
+  for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0])) code = code.slice(0, start) + text + code.slice(end);
+  if (isDep) {
+    code += `\nreturn { ${exported.map(([name, local]) => `${JSON.stringify(name)}: ${local}`).join(', ')} };`;
+  }
+  const tla = some(ast.program, (n) => n.type === 'AwaitExpression' || (n.type === 'ForOfStatement' && n.await), true);
+  if (isDep && tla) throw new Skip('top-level await in a dependency');
+  return { file, code, tla, name: `__ucode_${path.basename(file).replace(/\W/g, '_')}_${++ids}` };
+}
+
+/** Whether any node matches; with outsideFunctions, only nodes not inside a function. */
+function some(root, match, outsideFunctions) {
+  const stack = [root];
+  while (stack.length) {
+    const node = stack.pop();
+    if (!node || typeof node.type !== 'string') continue;
+    if (match(node)) return true;
+    if (outsideFunctions && /Function|ClassMethod|ObjectMethod/.test(node.type)) continue;
+    for (const key of Object.keys(node)) {
+      if (key === 'loc' || key === 'start' || key === 'end') continue;
+      const v = node[key];
+      if (Array.isArray(v)) stack.push(...v);
+      else if (v && typeof v === 'object') stack.push(v);
+    }
+  }
+  return false;
+}

package/src/core/window.js

@@ -1,225 +1,225 @@
-/**
- * window.js — keeping a long conversation inside the model's context.
- *
- * Two rules, both of which exist because the obvious alternative is worse:
- *
- *   Summarize the oldest turns rather than dropping them. Dropping means the
- *   agent forgets a decision it made an hour ago and quietly contradicts it.
- *
- *   Never cut between a tool call and its result. A result with no call above
- *   it is unreadable to the model and to anyone debugging the transcript.
- *
- * Only what gets sent is affected. history.js keeps the full record on disk
- * whatever happens here.
- */
-
-import { estimateConversation } from './provider.js';
-
-/** Start folding once the conversation passes this share of the window. */
-export const FOLD_AT = 0.75;
-
-/**
- * ...or once it passes this many tokens, whichever comes first.
- *
- * A share of the window is a correctness threshold: it stops the request
- * being rejected. It is the wrong measure for speed. These endpoints re-read
- * the whole conversation on every step and none of them cache it, so a
- * hundred thousand tokens is a hundred thousand tokens re-read ten times
- * before the app is finished — and on a million-token model, three quarters
- * of the window is a build that has been crawling for an hour by the time
- * anything is folded.
- *
- * Folding costs one model call. Past this size, that call has already paid
- * for itself in the steps that follow it.
- */
-export const FOLD_TOKENS = Number(process.env.UCODE_FOLD_TOKENS) || 80_000;
-
-/** After folding, the verbatim tail may occupy this share of the window. */
-export const KEEP = 0.4;
-
-export function usage(messages, limit) {
-  const used = estimateConversation(messages);
-  return {
-    used,
-    limit,
-    percent: limit > 0 ? Math.min(100, (used / limit) * 100) : 0,
-    left: Math.max(0, limit - used),
-  };
-}
-
-export function tooBig(messages, limit) {
-  return usage(messages, limit).used > foldAbove(limit);
-}
-
-/** The size at which folding starts: whichever of the two rules bites first. */
-export function foldAbove(limit) {
-  return Math.min(limit * FOLD_AT, FOLD_TOKENS);
-}
-
-/**
- * Where to cut so the kept tail stands on its own.
- *
- * Walks backwards accumulating messages until the budget runs out, then nudges
- * the boundary forward past any tool result whose call would have been folded
- * away.
- */
-function cutPoint(messages, budget) {
-  let cut = messages.length;
-  let left = budget;
-
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const cost = estimateConversation([messages[i]]);
-    if (left - cost < 0 && cut < messages.length) break;
-    left -= cost;
-    cut = i;
-  }
-
-  while (cut < messages.length && messages[cut].role === 'tool') cut++;
-
-  // Whatever else happens, the most recent exchange survives intact.
-  if (cut >= messages.length) cut = Math.max(0, messages.length - 1);
-  return cut;
-}
-
-/**
- * Fold the older half of a conversation into a summary, if it needs it.
- *
- * @param {Array} messages
- * @param {object} o
- * @param {number} o.limit          token budget
- * @param {Function} o.summarize    async (older, previousSummary) => string
- * @param {boolean}  [o.force]      fold even below the threshold — the provider
- *                                  has already said the request is too big
- */
-export async function fold(messages, { limit, summarize, force = false }) {
-  if (!force && !tooBig(messages, limit)) return { messages, folded: false };
-
-  // Half the size that triggered the fold, so there is room to work before
-  // the next one. Sized off the same absolute rule, or a fold on a
-  // million-token model would keep a tail that is instantly too big again and
-  // summarize on every single step.
-  const cut = cutPoint(messages, Math.min(limit * KEEP, foldAbove(limit) / 2));
-  const older = messages.slice(0, cut);
-  const recent = messages.slice(cut);
-
-  // Nothing old enough to fold — the tail on its own is already oversized.
-  if (older.length === 0) return { messages, folded: false };
-
-  // A second fold must not summarize the first summary as if it were chat:
-  // it is handed over as the prior summary, to be merged rather than retold.
-  const previous = older.find((m) => m.folded)?.summary ?? null;
-  const summary = await summarize(older.filter((m) => !m.folded), previous);
-
-  return {
-    folded: true,
-    summary,
-    droppedCount: older.length,
-    messages: [
-      {
-        role: 'system',
-        content:
-          `Summary of the earlier part of this conversation. ${older.length} messages ` +
-          `were folded away to stay inside the context window.\n\n${summary}\n\n` +
-          'Treat all of that as settled context. Everything after this point is verbatim.',
-        folded: true,
-        summary,
-      },
-      ...recent,
-    ],
-  };
-}
-
-/**
- * What the summarizer is asked to do: opencode's anchored summary (MIT, see
- * THIRD_PARTY_NOTICES.md). Fixed sections mean nothing gets dropped because
- * the summarizer found it dull — the next step and the files that matter
- * always have a place — and a second fold merges into the first instead of
- * summarizing a summary.
- */
-export const SUMMARY_PROMPT = `You summarize a coding session so another coding agent can continue the work with nothing else to go on.
-
-Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
-<template>
-## Objective
-- [one or two brief sentences describing what the user is trying to accomplish]
-
-## Important Details
-- [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
-
-## Work State
-### Completed
-- [finished work, verified facts, or changes made; otherwise "(none)"]
-
-### Active
-- [current work, partial changes, or investigation state; otherwise "(none)"]
-
-### Blocked
-- [blockers, failing commands, or unknowns; otherwise "(none)"]
-
-## Next Move
-1. [immediate concrete action, or "(none)"]
-2. [next action if known, or "(none)"]
-
-## Relevant Files
-- [file or directory path: why it matters, or "(none)"]
-</template>
-
-Rules:
-- Keep every section, even when empty.
-- Use terse bullets, not prose paragraphs.
-- Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
-- Do not mention the summary process or that context was compacted.`;
-
-const MERGE = `The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both. The <prior-summary> is discarded after this: anything you do not carry into the new summary is lost.
-
-When combining:
-- Carry forward objectives, constraints, user directives, decisions, and parallel workstreams from the <prior-summary> even when the <conversation> does not mention them. Drop only what is finished and no longer needed.
-- The <conversation> is more recent than the <prior-summary>. Where they conflict, the conversation wins: state the corrected fact and drop the old claim.
-- Add new progress, decisions, constraints, and context from the conversation.
-- Move completed work from "Active" to "Completed".
-- If a blocker has been resolved, update the summary to reflect that while keeping any details still needed to continue the work.
-- Update "Objective" and "Next Move" to reflect the current work state.`;
-
-/** The summarizer's user message: the conversation, and the summary it extends if there is one. */
-export function summaryRequest(conversation, previous = null) {
-  // File contents are in there too. One carrying "</conversation>" must not
-  // close the section early and speak to the summarizer as if it were us.
-  const fence = (s) => String(s).replace(/<\/?(?:conversation|prior-summary)>/gi, '');
-  conversation = fence(conversation);
-  if (previous) previous = fence(previous);
-  const parts = [`Here is the conversation so far:
-
-<conversation>
-${conversation}
-</conversation>`];
-  if (previous) {
-    parts.push(`Here is the summary of the conversation before the <conversation> above:
-
-<prior-summary>
-${previous}
-</prior-summary>`, MERGE);
-  } else {
-    parts.push('Create a new anchored summary from the conversation history in the <conversation> tags above so another coding agent can continue the work.');
-  }
-  return parts.join('\n\n');
-}
-
-/**
- * Flatten the messages being folded into plain text for the summarizer.
- * Tool traffic is included but trimmed — that a tool ran and roughly what it
- * returned matters; its exact bytes almost never do.
- */
-export function forSummary(messages) {
-  return messages
-    .map((m) => {
-      if (m.role === 'tool') return `[${m.name} returned]\n${(m.content || '').slice(0, 300)}`;
-      if (m.role === 'assistant') {
-        const calls = (m.toolCalls || [])
-          .map((c) => `[called ${c.name}(${JSON.stringify(c.args).slice(0, 200)})]`)
-          .join('\n');
-        return `assistant: ${m.content || ''}\n${calls}`.trim();
-      }
-      return `${m.role}: ${m.content || ''}`;
-    })
-    .join('\n\n');
-}
+/**
+ * window.js — keeping a long conversation inside the model's context.
+ *
+ * Two rules, both of which exist because the obvious alternative is worse:
+ *
+ *   Summarize the oldest turns rather than dropping them. Dropping means the
+ *   agent forgets a decision it made an hour ago and quietly contradicts it.
+ *
+ *   Never cut between a tool call and its result. A result with no call above
+ *   it is unreadable to the model and to anyone debugging the transcript.
+ *
+ * Only what gets sent is affected. history.js keeps the full record on disk
+ * whatever happens here.
+ */
+
+import { estimateConversation } from './provider.js';
+
+/** Start folding once the conversation passes this share of the window. */
+export const FOLD_AT = 0.75;
+
+/**
+ * ...or once it passes this many tokens, whichever comes first.
+ *
+ * A share of the window is a correctness threshold: it stops the request
+ * being rejected. It is the wrong measure for speed. These endpoints re-read
+ * the whole conversation on every step and none of them cache it, so a
+ * hundred thousand tokens is a hundred thousand tokens re-read ten times
+ * before the app is finished — and on a million-token model, three quarters
+ * of the window is a build that has been crawling for an hour by the time
+ * anything is folded.
+ *
+ * Folding costs one model call. Past this size, that call has already paid
+ * for itself in the steps that follow it.
+ */
+export const FOLD_TOKENS = Number(process.env.UCODE_FOLD_TOKENS) || 80_000;
+
+/** After folding, the verbatim tail may occupy this share of the window. */
+export const KEEP = 0.4;
+
+export function usage(messages, limit) {
+  const used = estimateConversation(messages);
+  return {
+    used,
+    limit,
+    percent: limit > 0 ? Math.min(100, (used / limit) * 100) : 0,
+    left: Math.max(0, limit - used),
+  };
+}
+
+export function tooBig(messages, limit) {
+  return usage(messages, limit).used > foldAbove(limit);
+}
+
+/** The size at which folding starts: whichever of the two rules bites first. */
+export function foldAbove(limit) {
+  return Math.min(limit * FOLD_AT, FOLD_TOKENS);
+}
+
+/**
+ * Where to cut so the kept tail stands on its own.
+ *
+ * Walks backwards accumulating messages until the budget runs out, then nudges
+ * the boundary forward past any tool result whose call would have been folded
+ * away.
+ */
+function cutPoint(messages, budget) {
+  let cut = messages.length;
+  let left = budget;
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const cost = estimateConversation([messages[i]]);
+    if (left - cost < 0 && cut < messages.length) break;
+    left -= cost;
+    cut = i;
+  }
+
+  while (cut < messages.length && messages[cut].role === 'tool') cut++;
+
+  // Whatever else happens, the most recent exchange survives intact.
+  if (cut >= messages.length) cut = Math.max(0, messages.length - 1);
+  return cut;
+}
+
+/**
+ * Fold the older half of a conversation into a summary, if it needs it.
+ *
+ * @param {Array} messages
+ * @param {object} o
+ * @param {number} o.limit          token budget
+ * @param {Function} o.summarize    async (older, previousSummary) => string
+ * @param {boolean}  [o.force]      fold even below the threshold — the provider
+ *                                  has already said the request is too big
+ */
+export async function fold(messages, { limit, summarize, force = false }) {
+  if (!force && !tooBig(messages, limit)) return { messages, folded: false };
+
+  // Half the size that triggered the fold, so there is room to work before
+  // the next one. Sized off the same absolute rule, or a fold on a
+  // million-token model would keep a tail that is instantly too big again and
+  // summarize on every single step.
+  const cut = cutPoint(messages, Math.min(limit * KEEP, foldAbove(limit) / 2));
+  const older = messages.slice(0, cut);
+  const recent = messages.slice(cut);
+
+  // Nothing old enough to fold — the tail on its own is already oversized.
+  if (older.length === 0) return { messages, folded: false };
+
+  // A second fold must not summarize the first summary as if it were chat:
+  // it is handed over as the prior summary, to be merged rather than retold.
+  const previous = older.find((m) => m.folded)?.summary ?? null;
+  const summary = await summarize(older.filter((m) => !m.folded), previous);
+
+  return {
+    folded: true,
+    summary,
+    droppedCount: older.length,
+    messages: [
+      {
+        role: 'system',
+        content:
+          `Summary of the earlier part of this conversation. ${older.length} messages ` +
+          `were folded away to stay inside the context window.\n\n${summary}\n\n` +
+          'Treat all of that as settled context. Everything after this point is verbatim.',
+        folded: true,
+        summary,
+      },
+      ...recent,
+    ],
+  };
+}
+
+/**
+ * What the summarizer is asked to do: opencode's anchored summary (MIT, see
+ * THIRD_PARTY_NOTICES.md). Fixed sections mean nothing gets dropped because
+ * the summarizer found it dull — the next step and the files that matter
+ * always have a place — and a second fold merges into the first instead of
+ * summarizing a summary.
+ */
+export const SUMMARY_PROMPT = `You summarize a coding session so another coding agent can continue the work with nothing else to go on.
+
+Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
+<template>
+## Objective
+- [one or two brief sentences describing what the user is trying to accomplish]
+
+## Important Details
+- [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
+
+## Work State
+### Completed
+- [finished work, verified facts, or changes made; otherwise "(none)"]
+
+### Active
+- [current work, partial changes, or investigation state; otherwise "(none)"]
+
+### Blocked
+- [blockers, failing commands, or unknowns; otherwise "(none)"]
+
+## Next Move
+1. [immediate concrete action, or "(none)"]
+2. [next action if known, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+</template>
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+
+const MERGE = `The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both. The <prior-summary> is discarded after this: anything you do not carry into the new summary is lost.
+
+When combining:
+- Carry forward objectives, constraints, user directives, decisions, and parallel workstreams from the <prior-summary> even when the <conversation> does not mention them. Drop only what is finished and no longer needed.
+- The <conversation> is more recent than the <prior-summary>. Where they conflict, the conversation wins: state the corrected fact and drop the old claim.
+- Add new progress, decisions, constraints, and context from the conversation.
+- Move completed work from "Active" to "Completed".
+- If a blocker has been resolved, update the summary to reflect that while keeping any details still needed to continue the work.
+- Update "Objective" and "Next Move" to reflect the current work state.`;
+
+/** The summarizer's user message: the conversation, and the summary it extends if there is one. */
+export function summaryRequest(conversation, previous = null) {
+  // File contents are in there too. One carrying "</conversation>" must not
+  // close the section early and speak to the summarizer as if it were us.
+  const fence = (s) => String(s).replace(/<\/?(?:conversation|prior-summary)>/gi, '');
+  conversation = fence(conversation);
+  if (previous) previous = fence(previous);
+  const parts = [`Here is the conversation so far:
+
+<conversation>
+${conversation}
+</conversation>`];
+  if (previous) {
+    parts.push(`Here is the summary of the conversation before the <conversation> above:
+
+<prior-summary>
+${previous}
+</prior-summary>`, MERGE);
+  } else {
+    parts.push('Create a new anchored summary from the conversation history in the <conversation> tags above so another coding agent can continue the work.');
+  }
+  return parts.join('\n\n');
+}
+
+/**
+ * Flatten the messages being folded into plain text for the summarizer.
+ * Tool traffic is included but trimmed — that a tool ran and roughly what it
+ * returned matters; its exact bytes almost never do.
+ */
+export function forSummary(messages) {
+  return messages
+    .map((m) => {
+      if (m.role === 'tool') return `[${m.name} returned]\n${(m.content || '').slice(0, 300)}`;
+      if (m.role === 'assistant') {
+        const calls = (m.toolCalls || [])
+          .map((c) => `[called ${c.name}(${JSON.stringify(c.args).slice(0, 200)})]`)
+          .join('\n');
+        return `assistant: ${m.content || ''}\n${calls}`.trim();
+      }
+      return `${m.role}: ${m.content || ''}`;
+    })
+    .join('\n\n');
+}