@moxxy/sdk 0.44.0 → 0.45.0

package/src/events.ts

@@ -74,11 +74,19 @@ export interface UserPromptAttachment {
  * `kind: 'voice'` marks the voice conversation (GPT-Live) held while an agent
  * turn ran and recorded after it as one transcript: context for later turns,
  * not a request, and shown as one collapsed block.
+ *
+ * `kind: 'agent'` opens a turn the vendor's agent of an agent connection
+ * started by itself (Claude after a task it ran in the background finished),
+ * or one Moxxy opened to show work the agent left running ending (Codex's
+ * helper or background command); `name` says what it took up. Nothing is
+ * sent to the agent for it.
  */
 export interface TriggerOrigin {
-  readonly kind: 'webhook' | 'schedule' | 'workflow' | 'checkpoint' | 'voice';
+  readonly kind: 'webhook' | 'schedule' | 'workflow' | 'checkpoint' | 'voice' | 'agent';
   /** The trigger's name (webhook/schedule/workflow/checkpoint), for the marker label. */
   readonly name: string;
+  /** `agent`: the background work whose end the agent took up (`AgentBackgroundWork.id`), when it says. */
+  readonly workId?: string;
 }
 
 export interface UserPromptEvent extends EventBase {
@@ -147,6 +155,8 @@ export interface ToolCallRequestedEvent extends EventBase {
   readonly name: string;
   readonly input: unknown;
   readonly skillContext?: SkillId;
+  /** Set when the provider's own agent ran the tool (an agent connection), not Moxxy. */
+  readonly executedBy?: 'provider';
 }
 
 export interface ToolCallApprovedEvent extends EventBase {
@@ -309,6 +319,12 @@ export interface ProviderResponseEvent extends EventBase {
   readonly outputTokens?: number;
   readonly cacheReadTokens?: number;
   readonly cacheCreationTokens?: number;
+  /**
+   * How many tokens the model's context holds after this response, when the usage
+   * above is not that: an agent connection reports one response per turn whose usage
+   * adds up every call the agent made.
+   */
+  readonly contextTokens?: number;
   readonly timing?: ProviderCallTiming;
 }
 

package/src/file-diff.test.ts

@@ -0,0 +1,103 @@
+/** A file change shown as a diff, whether Moxxy made it or an agent reported its own. */
+import { describe, expect, it } from 'vitest';
+import { diffPathIn, fileDiffFromPatch, fileDiffFromText, parseUnifiedDiff } from './file-diff.js';
+
+describe('a diff from the text before and after', () => {
+  it('shows the changed lines with two lines of context and their numbers', () => {
+    const d = fileDiffFromText({ path: 'a.ts', mode: 'update', before: 'a\nb\nc\nd\ne\nf\ng', after: 'a\nb\nc\nX\ne\nf\ng' });
+
+    expect(d).toMatchObject({ kind: 'file-diff', path: 'a.ts', mode: 'update', added: 1, removed: 1 });
+    expect(d.hunks).toHaveLength(1);
+    expect(d.hunks[0]?.lines).toEqual([
+      { kind: 'context', text: 'b', oldNo: 2, newNo: 2 },
+      { kind: 'context', text: 'c', oldNo: 3, newNo: 3 },
+      { kind: 'del', text: 'd', oldNo: 4 },
+      { kind: 'add', text: 'X', newNo: 4 },
+      { kind: 'context', text: 'e', oldNo: 5, newNo: 5 },
+      { kind: 'context', text: 'f', oldNo: 6, newNo: 6 },
+    ]);
+  });
+
+  it('shows a new file as all added', () => {
+    const d = fileDiffFromText({ path: 'new.ts', mode: 'create', before: '', after: 'one\ntwo\n' });
+
+    expect(d).toMatchObject({ mode: 'create', added: 2, removed: 0 });
+    expect(d.hunks[0]?.lines.map((line) => line.kind)).toEqual(['add', 'add']);
+  });
+});
+
+describe('a diff from patch hunks an agent reports', () => {
+  it('numbers the lines of each hunk from where it starts', () => {
+    const d = fileDiffFromPatch({
+      path: 'src/db.ts',
+      mode: 'update',
+      hunks: [{ oldStart: 10, newStart: 10, lines: [' const host = "x";', '-const port = 5432;', '+const port = 5433;', '+const pool = 4;'] }],
+    });
+
+    expect(d).toMatchObject({ added: 2, removed: 1 });
+    expect(d.hunks).toEqual([
+      {
+        oldStart: 10,
+        oldLines: 2,
+        newStart: 10,
+        newLines: 3,
+        lines: [
+          { kind: 'context', text: 'const host = "x";', oldNo: 10, newNo: 10 },
+          { kind: 'del', text: 'const port = 5432;', oldNo: 11 },
+          { kind: 'add', text: 'const port = 5433;', newNo: 11 },
+          { kind: 'add', text: 'const pool = 4;', newNo: 12 },
+        ],
+      },
+    ]);
+  });
+
+  it('skips the "no newline at end of file" marker', () => {
+    const d = fileDiffFromPatch({ path: 'a', mode: 'update', hunks: [{ oldStart: 1, newStart: 1, lines: ['-a', '\', '+b'] }] });
+
+    expect(d.hunks[0]?.lines.map((line) => line.text)).toEqual(['a', 'b']);
+  });
+
+  it('caps what it shows on a huge patch but counts every line', () => {
+    const lines = Array.from({ length: 1_000 }, (_, i) => `+line ${i}`);
+    const d = fileDiffFromPatch({ path: 'big', mode: 'create', hunks: [{ oldStart: 0, newStart: 1, lines }] });
+
+    expect(d.added).toBe(1_000);
+    expect(d.truncated).toBe(true);
+    expect(d.hunks[0]?.lines.length).toBeLessThan(1_000);
+  });
+});
+
+describe('reading a unified diff', () => {
+  it('reads each hunk and leaves out the file headers', () => {
+    const text = '--- a/x.ts\n+++ b/x.ts\n@@ -1 +1,2 @@\n-old\n+new\n+more\n@@ -20,3 +21,3 @@ function f() {\n a\n-b\n+c\n d\n';
+
+    expect(parseUnifiedDiff(text)).toEqual([
+      { oldStart: 1, newStart: 1, lines: ['-old', '+new', '+more'] },
+      { oldStart: 20, newStart: 21, lines: [' a', '-b', '+c', ' d'] },
+    ]);
+  });
+
+  it('finds no hunks in text that is not a diff', () => {
+    expect(parseUnifiedDiff('just some file content')).toEqual([]);
+  });
+});
+
+describe('the path a diff shows', () => {
+  it('is relative to the project folder when the file is inside it', () => {
+    expect(diffPathIn('/repo', '/repo/src/a.ts')).toBe('src/a.ts');
+    expect(diffPathIn('C:\\repo', 'C:\\repo\\src\\a.ts')).toBe('src\\a.ts');
+  });
+
+  it('stays as given outside the project folder', () => {
+    expect(diffPathIn('/repo', '/repository/a.ts')).toBe('/repository/a.ts');
+    expect(diffPathIn('/repo', 'src/a.ts')).toBe('src/a.ts');
+  });
+  it('ignores trailing separators on the project folder, in time linear in its length', () => {
+    expect(diffPathIn('/repo//', '/repo/src/a.ts')).toBe('src/a.ts');
+    expect(diffPathIn('C:\\repo\\', 'C:\\repo\\a.ts')).toBe('a.ts');
+
+    const started = performance.now();
+    diffPathIn(`${'/'.repeat(100_000)}x`, '/a.ts');
+    expect(performance.now() - started).toBeLessThan(500);
+  });
+});

package/src/file-diff.ts

@@ -0,0 +1,208 @@
+import type { DiffHunk, DiffLine, FileDiffDisplay } from './tool-display.js';
+
+/**
+ * File changes as `file-diff` displays, from what is at hand: the text before
+ * and after (Moxxy's Write/Edit, OpenCode), or patch hunks the agent already
+ * made (Claude's structured patch, Codex's unified diff). Only the changed
+ * slices are kept, so a display stays small whatever the file's size.
+ */
+
+/** A hunk as patches write it: lines prefixed with ' ', '+' or '-'. */
+export interface PatchHunk {
+  readonly oldStart: number;
+  readonly newStart: number;
+  readonly lines: ReadonlyArray<string>;
+}
+
+interface FileDiffTarget {
+  /** As the diff shows it; see `diffPathIn`. */
+  readonly path: string;
+  readonly mode: 'create' | 'update';
+}
+
+/** Context lines kept around each change. */
+const CONTEXT = 2;
+/** Diff lines shown at most; the counts still cover every line. */
+const MAX_DIFF_LINES = 400;
+/** Above this combined size (~2 MB) only the counts are given. */
+const MAX_DIFF_BYTES = 2_000_000;
+/** LCS table cell budget; above it the changed middle is one replace block. */
+const LCS_CELL_BUDGET = 1_000_000;
+
+type Change = { readonly kind: DiffLine['kind']; readonly text: string };
+
+export function fileDiffFromText(args: FileDiffTarget & { readonly before: string; readonly after: string }): FileDiffDisplay {
+  const before = toLines(args.before);
+  const after = toLines(args.after);
+  if (args.before.length + args.after.length > MAX_DIFF_BYTES) {
+    return { kind: 'file-diff', path: args.path, mode: args.mode, added: after.length, removed: before.length, hunks: [], truncated: true };
+  }
+  const lines = numberLines(1, 1, changesBetween(before, after));
+  const { hunks, truncated } = hunksAround(lines);
+  return display(args, lines, hunks, truncated);
+}
+
+export function fileDiffFromPatch(args: FileDiffTarget & { readonly hunks: ReadonlyArray<PatchHunk> }): FileDiffDisplay {
+  const all: DiffLine[] = [];
+  const hunks: DiffHunk[] = [];
+  let shown = 0;
+  let truncated = false;
+  for (const hunk of args.hunks) {
+    const lines = numberLines(hunk.oldStart, hunk.newStart, hunk.lines.flatMap(patchChange));
+    all.push(...lines);
+    if (truncated) continue;
+    const kept = lines.slice(0, MAX_DIFF_LINES - shown);
+    shown += kept.length;
+    if (kept.length < lines.length) truncated = true;
+    if (kept.length > 0) hunks.push(hunkOf(kept));
+  }
+  return display(args, all, hunks, truncated);
+}
+
+/** The hunks of a unified diff; file headers and anything outside a hunk are left out. */
+export function parseUnifiedDiff(text: string): PatchHunk[] {
+  const hunks: PatchHunk[] = [];
+  let current: { lines: string[]; oldLeft: number; newLeft: number } | undefined;
+  for (const line of text.split('\n')) {
+    if (current && (current.oldLeft > 0 || current.newLeft > 0 || line.startsWith('\\'))) {
+      // The header's counts say where the hunk ends; an empty line inside it is context written without its space.
+      if (line.startsWith('+')) current.newLeft -= 1;
+      else if (line.startsWith('-')) current.oldLeft -= 1;
+      else if (!line.startsWith('\\')) {
+        current.oldLeft -= 1;
+        current.newLeft -= 1;
+      }
+      current.lines.push(line);
+      continue;
+    }
+    const header = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!header) continue;
+    current = { lines: [], oldLeft: Number(header[2] ?? 1), newLeft: Number(header[4] ?? 1) };
+    hunks.push({ oldStart: Number(header[1]), newStart: Number(header[3]), lines: current.lines });
+  }
+  return hunks;
+}
+
+/** `file` relative to the project folder `cwd` when inside it, else as given; either separator. */
+export function diffPathIn(cwd: string, file: string): string {
+  let end = cwd.length;
+  while (end > 0 && (cwd[end - 1] === '/' || cwd[end - 1] === '\\')) end -= 1;
+  const root = cwd.slice(0, end);
+  if (root && file.startsWith(root) && (file[root.length] === '/' || file[root.length] === '\\')) return file.slice(root.length + 1);
+  return file;
+}
+
+function display(target: FileDiffTarget, lines: ReadonlyArray<DiffLine>, hunks: DiffHunk[], truncated: boolean): FileDiffDisplay {
+  return {
+    kind: 'file-diff',
+    path: target.path,
+    mode: target.mode,
+    added: lines.filter((line) => line.kind === 'add').length,
+    removed: lines.filter((line) => line.kind === 'del').length,
+    hunks,
+    ...(truncated ? { truncated: true } : {}),
+  };
+}
+
+/** Lines of a text; a single trailing newline ends the last line, as in diffs. */
+function toLines(text: string): string[] {
+  if (text.length === 0) return [];
+  return (text.endsWith('\n') ? text.slice(0, -1) : text).split('\n');
+}
+
+function patchChange(line: string): Change[] {
+  if (line.startsWith('+')) return [{ kind: 'add', text: line.slice(1) }];
+  if (line.startsWith('-')) return [{ kind: 'del', text: line.slice(1) }];
+  if (line.startsWith('\\')) return [];
+  return [{ kind: 'context', text: line.startsWith(' ') ? line.slice(1) : line }];
+}
+
+function numberLines(oldStart: number, newStart: number, changes: ReadonlyArray<Change>): DiffLine[] {
+  let oldNo = oldStart;
+  let newNo = newStart;
+  return changes.map((change) => {
+    if (change.kind === 'add') return { kind: 'add', text: change.text, newNo: newNo++ };
+    if (change.kind === 'del') return { kind: 'del', text: change.text, oldNo: oldNo++ };
+    return { kind: 'context', text: change.text, oldNo: oldNo++, newNo: newNo++ };
+  });
+}
+
+/** Every line of both texts in order, the common prefix and suffix trimmed before the LCS pass. */
+function changesBetween(before: ReadonlyArray<string>, after: ReadonlyArray<string>): Change[] {
+  let start = 0;
+  while (start < before.length && start < after.length && before[start] === after[start]) start += 1;
+  let endBefore = before.length;
+  let endAfter = after.length;
+  while (endBefore > start && endAfter > start && before[endBefore - 1] === after[endAfter - 1]) {
+    endBefore -= 1;
+    endAfter -= 1;
+  }
+  const context = (text: string): Change => ({ kind: 'context', text });
+  return [
+    ...before.slice(0, start).map(context),
+    ...lcs(before.slice(start, endBefore), after.slice(start, endAfter)),
+    ...before.slice(endBefore).map(context),
+  ];
+}
+
+function lcs(a: ReadonlyArray<string>, b: ReadonlyArray<string>): Change[] {
+  const removed = (text: string): Change => ({ kind: 'del', text });
+  const added = (text: string): Change => ({ kind: 'add', text });
+  if (a.length === 0 || b.length === 0 || a.length * b.length > LCS_CELL_BUDGET) return [...a.map(removed), ...b.map(added)];
+  // common[i * width + j] = length of the longest common run of a[i:] and b[j:].
+  const width = b.length + 1;
+  const common = new Uint32Array((a.length + 1) * width);
+  const at = (i: number, j: number): number => common[i * width + j] ?? 0;
+  for (let i = a.length - 1; i >= 0; i -= 1) {
+    for (let j = b.length - 1; j >= 0; j -= 1) {
+      common[i * width + j] = a[i] === b[j] ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
+    }
+  }
+  const changes: Change[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    const left = a[i] ?? '';
+    const right = b[j] ?? '';
+    if (left === right) {
+      changes.push({ kind: 'context', text: left });
+      i += 1;
+      j += 1;
+    } else if (at(i + 1, j) >= at(i, j + 1)) {
+      changes.push(removed(left));
+      i += 1;
+    } else {
+      changes.push(added(right));
+      j += 1;
+    }
+  }
+  return [...changes, ...a.slice(i).map(removed), ...b.slice(j).map(added)];
+}
+
+/** The changed lines with CONTEXT lines around them, grouped into hunks and capped at MAX_DIFF_LINES. */
+function hunksAround(lines: ReadonlyArray<DiffLine>): { hunks: DiffHunk[]; truncated: boolean } {
+  const ranges: Array<[number, number]> = [];
+  lines.forEach((line, index) => {
+    if (line.kind === 'context') return;
+    const lo = Math.max(0, index - CONTEXT);
+    const hi = Math.min(lines.length - 1, index + CONTEXT);
+    const last = ranges[ranges.length - 1];
+    if (last && lo <= last[1] + 1) last[1] = Math.max(last[1], hi);
+    else ranges.push([lo, hi]);
+  });
+  const hunks: DiffHunk[] = [];
+  let shown = 0;
+  for (const [lo, hi] of ranges) {
+    const kept = lines.slice(lo, Math.min(hi + 1, lo + MAX_DIFF_LINES - shown));
+    shown += kept.length;
+    if (kept.length > 0) hunks.push(hunkOf(kept));
+    if (kept.length < hi + 1 - lo) return { hunks, truncated: true };
+  }
+  return { hunks, truncated: false };
+}
+
+function hunkOf(lines: ReadonlyArray<DiffLine>): DiffHunk {
+  const olds = lines.flatMap((line) => (line.oldNo === undefined ? [] : [line.oldNo]));
+  const news = lines.flatMap((line) => (line.newNo === undefined ? [] : [line.newNo]));
+  return { oldStart: olds[0] ?? 0, oldLines: olds.length, newStart: news[0] ?? 0, newLines: news.length, lines };
+}

package/src/index.ts

@@ -137,10 +137,46 @@ export type {
 export {
   AUTO_APPROVE_PLUGIN_ID,
   AUTO_APPROVE_SUBTYPE,
+  AUTO_APPROVE_RESTORED_SUBTYPE,
+  autoApproveFromAgent,
   autoApproveFromEvents,
+  autoApproveRecorded,
   autoApproveSwitch,
 } from './auto-approve.js';
 
+export {
+  QUESTION_PLUGIN_ID,
+  QUESTION_ASKED,
+  QUESTION_RESOLVED,
+  QUESTION_CLOSED_AGENT_WENT_ON,
+  QUESTION_CLOSED_NEW_MESSAGE,
+  questionCloseNote,
+  questionOptionSchema,
+  questionItemSchema,
+  questionAnswerSchema,
+  questionAnswersSchema,
+  questionRecord,
+  openQuestionsFromEvents,
+  questionAnswersProblem,
+  describeQuestionAnswers,
+  questionAnswerDisplay,
+} from './question.js';
+export type {
+  QuestionOption,
+  QuestionItem,
+  QuestionAnswer,
+  QuestionAnswers,
+  QuestionCloseNote,
+  QuestionAskOptions,
+  QuestionOutcome,
+  QuestionRecord,
+  OpenQuestion,
+  QuestionAsker,
+  SessionQuestions,
+} from './question.js';
+export { emptyDraft, chooseOption, typeOwnAnswer, draftAnswers } from './question-draft.js';
+export type { QuestionDraft } from './question-draft.js';
+
 export type {
   ClientSession,
   ProvidersClientView,
@@ -162,6 +198,7 @@ export type {
   PendingToolCall,
   PermissionContext,
   PermissionResolver,
+  StandingAllowRule,
 } from './permission.js';
 
 export type {
@@ -221,7 +258,69 @@ export type {
   ProviderOAuthResult,
   ProviderOAuthStatus,
   ProviderAuthDescriptor,
+  AgentCliState,
+  AgentCliOrigin,
+  AgentCliReport,
+  ProviderAgentCli,
+} from './provider.js';
+export type {
+  AgentStepRequest,
+  AgentStepHost,
+  AgentTurnStart,
+  AgentActivity,
+  AgentBackgroundWork,
+  AgentScheduledWakeup,
+  AgentWorkEnd,
+  AgentStepEvent,
+  AgentGoalStatus,
+  AgentOwnModes,
+  AgentToolCall,
+  AgentToolOutcome,
+  AgentApprovalRequest,
+  AgentApprovalDecision,
 } from './provider.js';
+export { startingModel } from './starting-model.js';
+export {
+  ACCOUNT_LIMIT_NEAR_PERCENT,
+  AGENT_ACCOUNT_LIMIT_SUBTYPE,
+  accountLimitInForce,
+  accountLimitOfEvent,
+  recordedAccountLimit,
+  sameAccountLimit,
+  withKnownReset,
+  type AgentAccountLimit,
+  type RecordedAccountLimit,
+} from './agent-account-limit.js';
+export {
+  AGENT_CONTEXT_WINDOW_SUBTYPE,
+  contextWindowOfEvent,
+  isContextWindowSize,
+  recordedContextWindows,
+  withRecordedContextWindows,
+  type RecordedContextWindow,
+} from './agent-context-window.js';
+export { AGENT_NO_REPLY_SUBTYPE, AGENT_NO_REPLY_TEXT, isAgentNoReplyEvent } from './agent-no-reply.js';
+export {
+  AGENT_BACKGROUND_WORK_ENDED_SUBTYPE,
+  AGENT_BACKGROUND_WORK_SUBTYPE,
+  AGENT_WORK_OUTPUT_LIMIT,
+  SUBAGENT_MESSAGE_SUBTYPE,
+  agentActivityRecord,
+  isAgentWorkEvent,
+  isSubagentEvent,
+  type AgentActivityRecord,
+  type SubagentNames,
+} from './agent-work.js';
+export { AGENT_CONNECTION_PLUGIN_ID, AGENT_GOAL_SUBTYPE, AGENT_SESSION_SUBTYPE, SUBAGENTS_PLUGIN_ID, agentSessionFromEvents } from './agent-step.js';
+export {
+  conversationTurns,
+  EARLIER_CONVERSATION_CHARS,
+  renderEarlierConversation,
+  renderMissedTurns,
+  searchConversation,
+  type ConversationMatch,
+  type ConversationTurn,
+} from './conversation-history.js';
 export {
   encodeLoginAuthUrl,
   decodeLoginAuthUrl,
@@ -236,18 +335,36 @@ export type {
   DiffHunk,
   DiffRow,
   FileDiffDisplay,
+  AnsweredQuestion,
+  QuestionAnswerDisplay,
+  ListedStep,
+  StepListDisplay,
+  StepStatus,
   ToolDisplay,
   ToolDisplayResult,
+  ToolImage,
 } from './tool-display.js';
 export {
   isToolDisplayResult,
   isToolDisplay,
   isFileDiffDisplay,
+  isQuestionAnswerDisplay,
+  isStepListDisplay,
+  stepStatusOf,
+  stepsFromTodos,
+  stepListOutput,
+  stepListProgress,
+  questionAnswerLines,
   fileDiffSummary,
   fileDiffVerb,
   diffGutterNo,
   toDiffRows,
+  toolImagesOf,
+  imageToolOutput,
 } from './tool-display.js';
+export { fileDiffFromText, fileDiffFromPatch, parseUnifiedDiff, diffPathIn, type PatchHunk } from './file-diff.js';
+export { agentComputerUseOf, type AgentComputerUse } from './agent-computer-use.js';
+export { toolOutputForModel, type ToolOutputForModel, type ToolImageBlock } from './tool-output.js';
 export type {
   ViewNode,
   ViewAction,
@@ -341,7 +458,10 @@ export {
   createCallbackResolver,
   createAllowListResolver,
   createDeferredPermissionResolver,
+  createSessionGrants,
+  alwaysAllowRule,
   evaluateToolRule,
+  type SessionGrants,
   type CallbackResolverOptions,
   type PermissionPromptHandler,
   type DeferredPermissionResolver,
@@ -663,5 +783,5 @@ export {
   type InstallTarget,
 } from './install-hints.js';
 
-export { z } from 'zod';
+export { z } from 'zod/v3';
 export { workflowApprovalItemSchema, workflowApprovalItemsSchema } from './workflow-approval.js';

package/src/json-file-store.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { posixFileModes } from '@moxxy/vitest-preset/platform';
-import { z } from 'zod';
+import { z } from 'zod/v3';
 import { createJsonFileStore } from './json-file-store.js';
 import { removeDir } from '@moxxy/vitest-preset/fs';
 

package/src/loop-helpers.test.ts

@@ -192,6 +192,21 @@ describe('projectMessagesFromLog', () => {
     }
   });
 
+  it('projects only the text of an answered Question, not the copy kept for the transcript', () => {
+    const output = {
+      forModel: 'The user answered:\n- "Which colour?" → Blue',
+      display: { kind: 'question-answer' as const, questions: [{ question: 'Which colour?', chosen: ['Blue'] }] },
+    };
+    const log = reader([
+      event(0, { type: 'user_prompt', turnId: t1, source: 'user', text: 'make a button' }),
+      event(1, { type: 'tool_call_requested', turnId: t1, source: 'model', callId: 'c1', name: 'ask_user', input: {} }),
+      event(2, { type: 'tool_result', turnId: t1, source: 'tool', callId: 'c1', ok: true, output }),
+    ]);
+
+    const toolResult = projectMessagesFromLog({ log }).find((m) => m.role === 'tool_result');
+    expect(toolResult?.content[0]).toMatchObject({ type: 'tool_result', content: output.forModel });
+  });
+
   it('projects an image-shaped tool result as an image block, not stringified text', () => {
     // A screenshot/clipboard tool returns { mediaType, base64 }. The model must
     // SEE the pixels (image block), not a giant base64 string JSON-stringified