@moxxy/sdk 0.10.0 → 0.12.0

package/src/provider-login-bridge.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import {
+  createLoginStreamScanner,
+  decodeLoginPrompt,
+  encodeLoginPrompt,
+  type LoginStreamItem,
+} from './provider-login-bridge.js';
+
+describe('encode/decode login prompt', () => {
+  it('round-trips a request', () => {
+    const marker = encodeLoginPrompt({ question: 'Paste token:', mask: true });
+    // NUL-bracketed.
+    expect(marker.startsWith('\u0000')).toBe(true);
+    expect(marker.endsWith('\u0000')).toBe(true);
+    const inner = marker.slice(1, -1);
+    expect(decodeLoginPrompt(inner)).toEqual({ question: 'Paste token:', mask: true });
+  });
+
+  it('rejects non-marker segments', () => {
+    expect(decodeLoginPrompt('just text')).toBeNull();
+    expect(decodeLoginPrompt('{"tag":"other","question":"x"}')).toBeNull();
+    expect(decodeLoginPrompt('{not json')).toBeNull();
+  });
+});
+
+/** Drain a scanner across the given chunks into a flat item list. */
+function scanAll(chunks: string[]): LoginStreamItem[] {
+  const scanner = createLoginStreamScanner();
+  return chunks.flatMap((c) => [...scanner.push(c)]);
+}
+
+describe('createLoginStreamScanner', () => {
+  it('passes plain output straight through', () => {
+    expect(scanAll(['hello world'])).toEqual([{ type: 'output', text: 'hello world' }]);
+  });
+
+  it('extracts a marker with surrounding output', () => {
+    const stream = 'opening browser\n' + encodeLoginPrompt({ question: 'Paste code:', mask: false }) + 'done\n';
+    expect(scanAll([stream])).toEqual([
+      { type: 'output', text: 'opening browser\n' },
+      { type: 'prompt', prompt: { question: 'Paste code:', mask: false } },
+      { type: 'output', text: 'done\n' },
+    ]);
+  });
+
+  it('reassembles a marker split across chunks', () => {
+    const marker = encodeLoginPrompt({ question: 'Paste token:', mask: true });
+    const mid = Math.floor(marker.length / 2);
+    const items = scanAll(['prefix', marker.slice(0, mid), marker.slice(mid), 'suffix']);
+    expect(items).toEqual([
+      { type: 'output', text: 'prefix' },
+      { type: 'prompt', prompt: { question: 'Paste token:', mask: true } },
+      { type: 'output', text: 'suffix' },
+    ]);
+  });
+
+  it('handles two prompts in sequence', () => {
+    const a = encodeLoginPrompt({ question: 'first', mask: false });
+    const b = encodeLoginPrompt({ question: 'second', mask: true });
+    expect(scanAll([a + b])).toEqual([
+      { type: 'prompt', prompt: { question: 'first', mask: false } },
+      { type: 'prompt', prompt: { question: 'second', mask: true } },
+    ]);
+  });
+
+  it('holds back a lone opening NUL until its partner arrives', () => {
+    const scanner = createLoginStreamScanner();
+    const marker = encodeLoginPrompt({ question: 'q', mask: false });
+    // Feed everything except the closing NUL: nothing should surface yet.
+    expect([...scanner.push('text' + marker.slice(0, -1))]).toEqual([
+      { type: 'output', text: 'text' },
+    ]);
+    // Closing NUL completes the marker.
+    expect([...scanner.push('\u0000')]).toEqual([
+      { type: 'prompt', prompt: { question: 'q', mask: false } },
+    ]);
+  });
+});

package/src/provider-login-bridge.ts

@@ -0,0 +1,105 @@
+/**
+ * Cross-process bridge for relaying a provider login's interactive prompts —
+ * the out-of-band token / authorization-code paste that `claude-code` needs —
+ * from a spawned `moxxy login --stdin-prompts` subprocess to a GUI host that
+ * has no TTY (the desktop app).
+ *
+ * The subprocess emits each `ctx.prompt(question)` call as a NUL-bracketed
+ * JSON marker on stdout. NUL never appears in normal terminal output, so the
+ * host can scan the byte stream for these markers, render the prompt, and
+ * write the user's answer back as one stdin line. Loopback flows that never
+ * call `ctx.prompt` (e.g. openai-codex, which captures the code via a local
+ * callback server) emit no markers — the host just streams their output and
+ * waits for the process to exit.
+ *
+ * Living here (not in the CLI or the desktop contract) keeps the one wire
+ * format in a package both the CLI producer and the desktop consumer already
+ * depend on, so the two ends can never drift.
+ */
+
+/** The byte that brackets a prompt marker. Absent from normal CLI output. */
+const NUL = '\u0000';
+
+/** Tag distinguishing a login-prompt marker from any other NUL-bracketed run. */
+const PROMPT_TAG = 'moxxy.login.prompt';
+
+export interface LoginPromptRequest {
+  /** The question to show the user, verbatim from `ctx.prompt`. */
+  readonly question: string;
+  /** True for secrets — the host should mask the input field. */
+  readonly mask: boolean;
+}
+
+/** One decoded item from a login subprocess's stdout stream. */
+export type LoginStreamItem =
+  | { readonly type: 'output'; readonly text: string }
+  | { readonly type: 'prompt'; readonly prompt: LoginPromptRequest };
+
+/**
+ * Serialize a prompt request as a NUL-bracketed marker for stdout. The
+ * leading NUL also delimits it from any partial preceding `ctx.write` output
+ * the host scanner has buffered.
+ */
+export function encodeLoginPrompt(req: LoginPromptRequest): string {
+  return NUL + JSON.stringify({ tag: PROMPT_TAG, question: req.question, mask: req.mask }) + NUL;
+}
+
+/**
+ * Try to parse a single inter-NUL segment as a prompt marker. Returns null
+ * when it isn't one, so the host can pass the segment through as output.
+ */
+export function decodeLoginPrompt(segment: string): LoginPromptRequest | null {
+  if (!segment.startsWith('{')) return null;
+  try {
+    const o = JSON.parse(segment) as Record<string, unknown>;
+    if (o.tag !== PROMPT_TAG || typeof o.question !== 'string') return null;
+    return { question: o.question, mask: o.mask === true };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Streaming scanner for a login subprocess's stdout. Feed it chunks; it
+ * returns the ordered output / prompt items decoded so far, holding back any
+ * incomplete trailing marker (an opening NUL with no closing NUL yet) until
+ * the rest of it arrives in a later chunk.
+ */
+export function createLoginStreamScanner(): {
+  push(chunk: string): ReadonlyArray<LoginStreamItem>;
+} {
+  let buf = '';
+  return {
+    push(chunk: string): ReadonlyArray<LoginStreamItem> {
+      buf += chunk;
+      const out: LoginStreamItem[] = [];
+      // Consume every COMPLETE marker (NUL <json> NUL), emitting the plain
+      // text before each as output. Stop at the first NUL with no closing
+      // partner — that's a marker still mid-flight, kept for the next chunk.
+      for (;;) {
+        const open = buf.indexOf(NUL);
+        if (open === -1) break;
+        const close = buf.indexOf(NUL, open + 1);
+        if (close === -1) break;
+        if (open > 0) out.push({ type: 'output', text: buf.slice(0, open) });
+        const segment = buf.slice(open + 1, close);
+        const prompt = decodeLoginPrompt(segment);
+        // A NUL-bracketed run that isn't a valid marker is anomalous; surface
+        // its inner text as output rather than swallowing it.
+        out.push(prompt ? { type: 'prompt', prompt } : { type: 'output', text: segment });
+        buf = buf.slice(close + 1);
+      }
+      // Flush any plain text that precedes a still-incomplete marker (or all
+      // of it when no NUL is pending), keeping only the partial marker.
+      const pending = buf.indexOf(NUL);
+      if (pending === -1) {
+        if (buf) out.push({ type: 'output', text: buf });
+        buf = '';
+      } else if (pending > 0) {
+        out.push({ type: 'output', text: buf.slice(0, pending) });
+        buf = buf.slice(pending);
+      }
+      return out;
+    },
+  };
+}

package/src/provider.ts

@@ -19,7 +19,24 @@ export type ContentBlock =
    * to a text placeholder. Text/Office files are inlined as `text` instead — only
    * formats a model ingests as bytes become `document` blocks.
    */
-  | { readonly type: 'document'; readonly mediaType: string; readonly data: string; readonly name?: string };
+  | { readonly type: 'document'; readonly mediaType: string; readonly data: string; readonly name?: string }
+  /**
+   * A model reasoning/thinking block, preserved in conversation history so it
+   * can be replayed on the next request. Anthropic REQUIRES the signed
+   * `thinking` block be sent back (as the first block of an assistant turn that
+   * also carries tool_use) on an interleaved-thinking continuation — a missing
+   * or unsigned block is a hard 400, so the loop drops unsigned reasoning from
+   * what it replays. `redacted` blocks carry only `encrypted` (the opaque blob)
+   * and `text: ''`; they are replayed verbatim, never shown. Providers without
+   * reasoning ignore this block.
+   */
+  | {
+      readonly type: 'reasoning';
+      readonly text: string;
+      readonly signature?: string;
+      readonly redacted?: boolean;
+      readonly encrypted?: string;
+    };
 
 /**
  * Provider-neutral instruction for where a prompt-cache breakpoint should be
@@ -56,6 +73,15 @@ export interface ProviderRequest {
   readonly signal?: AbortSignal;
   /** Where to place prompt-cache breakpoints. Set by the active CacheStrategy. */
   readonly cacheHints?: ReadonlyArray<CacheHint>;
+  /**
+   * Request reasoning/thinking from the model. `false`/absent = off. Providers
+   * gate on this AND the model descriptor's `supportsReasoning`; unsupported
+   * providers/models ignore it. The loop sets it from the active provider's
+   * reasoning config (see the per-provider reasoning setting). `effort` maps to
+   * each provider's native knob (Anthropic thinking budget, OpenAI/Codex
+   * `reasoning.effort`).
+   */
+  readonly reasoning?: { readonly effort?: 'low' | 'medium' | 'high' } | boolean;
 }
 
 export type ProviderEvent =
@@ -65,7 +91,17 @@ export type ProviderEvent =
   | { readonly type: 'tool_use_delta'; readonly id: string; readonly partialInput: string }
   | { readonly type: 'tool_use_end'; readonly id: string; readonly input: unknown }
   | { readonly type: 'message_end'; readonly stopReason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'error'; readonly usage?: TokenUsage }
-  | { readonly type: 'error'; readonly message: string; readonly retryable: boolean };
+  | { readonly type: 'error'; readonly message: string; readonly retryable: boolean }
+  /** A streamed reasoning/thinking text delta (visible summary). */
+  | { readonly type: 'reasoning_delta'; readonly delta: string }
+  /**
+   * End-of-reasoning-block metadata for history round-trip, emitted once per
+   * reasoning block. `signature` is Anthropic's thinking-block signature;
+   * `encrypted` carries an opaque blob (Anthropic redacted_thinking data /
+   * Codex reasoning encrypted_content) that must be replayed verbatim;
+   * `redacted` marks reasoning that must never be displayed.
+   */
+  | { readonly type: 'reasoning_signature'; readonly signature?: string; readonly redacted?: boolean; readonly encrypted?: string };
 
 export interface TokenUsage {
   readonly inputTokens: number;
@@ -101,6 +137,13 @@ export interface ModelDescriptor {
    * the transcript as text instead.
    */
   readonly supportsAudio?: boolean;
+  /**
+   * Whether this model can emit reasoning/thinking summaries (Anthropic
+   * extended thinking, OpenAI o-series / Codex reasoning). Gates the
+   * per-provider reasoning config UI and whether the loop requests reasoning
+   * for this model. When false, `ProviderRequest.reasoning` is ignored.
+   */
+  readonly supportsReasoning?: boolean;
 }
 
 export interface LLMProvider {

package/src/session-like.ts

@@ -57,6 +57,12 @@ export interface ProviderInfo {
    *  via /v1/models). Lets the desktop's model picker show a
    *  "Fetch live" affordance only where it makes sense. */
   readonly supportsLiveModelDiscovery: boolean;
+  /**
+   * False when the user disabled this provider (it stays registered but can't
+   * be activated and is excluded from boot's candidate walk). Optional for
+   * wire back-compat — an older runner omits it; treat absent as enabled.
+   */
+  readonly enabled?: boolean;
 }
 
 /** Serializable tool metadata for status lines / slash menus / compact rendering. */
@@ -146,6 +152,36 @@ export interface McpAdminView {
   listServers(): Promise<ReadonlyArray<McpServerStatusView>>;
 }
 
+/**
+ * Editable fields of a stored (runtime-registered) provider entry. Mirrors
+ * the persisted `providers.json` shape owned by `@moxxy/plugin-provider-admin`
+ * minus the immutable identity (`name`, `kind`).
+ */
+export interface ProviderConfigurePatch {
+  readonly baseURL?: string;
+  readonly defaultModel?: string;
+  /** Override the API-key env-var/vault name (`<NAME>_API_KEY` by default). */
+  readonly envVar?: string;
+  readonly models?: ReadonlyArray<ModelDescriptor>;
+}
+
+/**
+ * The slice of the provider admin API a channel needs to edit a stored
+ * (runtime-registered) provider in place. Present on a local Session when
+ * `@moxxy/plugin-provider-admin` is wired (mirrors {@link McpAdminView});
+ * a `RemoteSession` proxies it over the runner protocol (v7+). Built-in
+ * providers are not configurable through this view — their config is code.
+ */
+export interface ProviderAdminView {
+  /**
+   * Patch a stored provider's entry: re-registers the live provider def and
+   * persists the merged entry to providers.json. Throws a MoxxyError when no
+   * stored provider has that name or the patch is inconsistent (e.g. a
+   * defaultModel missing from the models list).
+   */
+  configure(name: string, patch: ProviderConfigurePatch): Promise<void>;
+}
+
 /** One workflow's summary for the `/workflows` modal. */
 export interface WorkflowSummaryView {
   readonly name: string;
@@ -308,6 +344,8 @@ export interface SessionLike {
   credentialResolver?: CredentialResolver;
   /** MCP admin slice backing the MCP picker / status line. */
   mcpAdmin?: McpAdminView;
+  /** Provider admin slice — edit stored (runtime-registered) providers. */
+  providerAdmin?: ProviderAdminView;
   /** Workflows slice backing the `/workflows` modal. */
   workflows?: WorkflowsView;
   /** Plugin-management slice backing the `/plugins` picker. */

package/src/subagent.ts

@@ -26,6 +26,12 @@ export interface SubagentSpec {
   readonly allowedTools?: ReadonlyArray<string>;
   /** Human-readable label surfaced in `subagent_*` event payloads. */
   readonly label?: string;
+  /**
+   * Named kind this child was spawned as (e.g. `'Explore'`, `'code-reviewer'`).
+   * Surfaced in `subagent_*` payloads so sibling agents of the same kind group
+   * under one collapsible header. Defaults to `'default'`.
+   */
+  readonly agentType?: string;
   /**
    * When true, the child session stays alive after the first turn for
    * {@link SubagentSpawner.continue}. `subagent_completed` is deferred until

package/src/surface.ts

@@ -0,0 +1,173 @@
+/**
+ * A Surface is a long-lived, interactive pane that BOTH a human viewer (a
+ * desktop panel) and the agent drive together: an embedded terminal (a shared
+ * PTY) or an in-window browser (a shared page). Unlike a {@link Channel} — which
+ * is a whole conversation transport — a Surface is a single resource attached to
+ * an existing Session, streaming opaque output frames out and accepting opaque
+ * input messages in.
+ *
+ * Surfaces are RUNNER-OWNED: the underlying resource (PTY, Playwright page) lives
+ * in the same process as the agent's tools, so the agent reads/writes the exact
+ * same instance the user watches. A thin client (the desktop) renders the
+ * streamed frames and relays the user's input back over the runner protocol —
+ * there is no reverse RPC. Plugins contribute surfaces via
+ * `definePlugin({ surfaces: [defineSurface(...)] })`; the plugin's own tools
+ * (e.g. `terminal`, `browser_session`) share the resource through module state.
+ *
+ * The payloads (`SurfaceDataMessage.payload`, `SurfaceInputMessage`) are
+ * deliberately opaque (`unknown` / open record): they cross the JSON-RPC wire
+ * verbatim and each surface kind defines its own shape (PTY bytes, a base64
+ * frame, a navigate request). Keeping them untyped here means a new surface kind
+ * never has to touch this file or the protocol.
+ */
+
+/**
+ * Surface kind discriminator. Open string union so plugins add kinds without
+ * editing the SDK; the built-ins are `'terminal'` and `'browser'`.
+ */
+export type SurfaceKind = 'terminal' | 'browser' | (string & {});
+
+/** One outbound frame from a surface instance to its viewers. */
+export interface SurfaceDataMessage {
+  /** The instance this frame belongs to (a viewer may watch several). */
+  readonly surfaceId: string;
+  readonly kind: SurfaceKind;
+  /** Surface-specific payload (PTY text, a base64 frame, a url/title update). */
+  readonly payload: unknown;
+}
+
+/**
+ * One inbound message from a viewer to a surface instance — a keystroke, a
+ * mouse event, a navigate request, a resize. `type` discriminates; the rest is
+ * surface-specific.
+ */
+export interface SurfaceInputMessage {
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+
+/** Viewport hint for a resize (terminal cols/rows or pixel width/height). */
+export interface SurfaceSize {
+  readonly cols?: number;
+  readonly rows?: number;
+  readonly width?: number;
+  readonly height?: number;
+}
+
+/**
+ * A live, attached surface instance — the running PTY or browser page. Opening
+ * the same kind twice returns the SAME instance (surfaces are shared), so a
+ * viewer that joins late gets the existing resource plus its {@link snapshot}.
+ */
+export interface SurfaceInstance {
+  readonly id: string;
+  readonly kind: SurfaceKind;
+  /** Subscribe to outbound frames. Returns an unsubscribe fn. */
+  onData(cb: (payload: unknown) => void): () => void;
+  /**
+   * A catch-up payload for a late-joining viewer (terminal scrollback, the last
+   * browser frame, the current url). Optional — a surface with no replayable
+   * state omits it.
+   */
+  snapshot?(): unknown;
+  /** Apply an inbound message from a viewer (or the agent's tool). */
+  input(msg: SurfaceInputMessage): void | Promise<void>;
+  /** Re-size the viewport, when the surface is size-aware. */
+  resize?(size: SurfaceSize): void | Promise<void>;
+  /**
+   * Detach this instance. The underlying shared resource MAY persist (the
+   * agent's tool can still use the PTY/page); `close` just tears down streaming
+   * + viewer state. A surface that owns its resource exclusively disposes it.
+   */
+  close(): void | Promise<void>;
+}
+
+/** Whether a surface kind can run right now (e.g. node-pty present). */
+export interface SurfaceAvailability {
+  readonly ok: boolean;
+  /** Human-readable explanation when `ok` is false (shown in the empty pane). */
+  readonly reason?: string;
+}
+
+/** Context handed to a surface when it opens. */
+export interface SurfaceContext {
+  /** Working directory of the owning Session. */
+  readonly cwd: string;
+  readonly logger?: {
+    debug?(msg: string, meta?: Record<string, unknown>): void;
+    info?(msg: string, meta?: Record<string, unknown>): void;
+    warn?(msg: string, meta?: Record<string, unknown>): void;
+    error?(msg: string, meta?: Record<string, unknown>): void;
+  };
+}
+
+/**
+ * A registered, named factory for a Surface. `open` is idempotent per kind: a
+ * second `open` attaches to the resource the first one created (the host
+ * enforces this), so the agent's tool and the user's pane share one instance.
+ */
+export interface SurfaceDef {
+  readonly kind: SurfaceKind;
+  readonly description?: string;
+  open(ctx: SurfaceContext): Promise<SurfaceInstance> | SurfaceInstance;
+  /** Optional runtime gate (default: always available). */
+  isAvailable?(ctx: SurfaceContext): Promise<SurfaceAvailability> | SurfaceAvailability;
+}
+
+/** Identity helper mirroring `defineTool` / `defineChannel`. */
+export function defineSurface(def: SurfaceDef): SurfaceDef {
+  return def;
+}
+
+/**
+ * Read-only registry of surface defs contributed by plugins. Implementation
+ * lives in @moxxy/core.
+ */
+export interface SurfaceRegistry {
+  list(): ReadonlyArray<SurfaceDef>;
+  get(kind: SurfaceKind): SurfaceDef | undefined;
+  has(kind: SurfaceKind): boolean;
+}
+
+/** Wire-friendly surface descriptor for `surface.list` (no functions). */
+export interface SurfaceInfo {
+  readonly kind: SurfaceKind;
+  readonly description?: string;
+  readonly available: boolean;
+  /** Why it is unavailable, when `available` is false. */
+  readonly reason?: string;
+}
+
+/** Result of opening a surface — its id + a catch-up snapshot for the viewer. */
+export interface OpenSurfaceResult {
+  readonly surfaceId: string;
+  readonly kind: SurfaceKind;
+  readonly snapshot?: unknown;
+}
+
+/**
+ * The runtime manager of open surface instances, present on an in-process
+ * `Session`. The runner server drives it on behalf of attached clients; the
+ * agent's tools reach the SAME underlying resources through plugin module state.
+ * Output from every open instance is multiplexed through {@link onData}.
+ */
+export interface SurfaceHost {
+  /** Available surface kinds with their current availability. */
+  list(): Promise<ReadonlyArray<SurfaceInfo>>;
+  /** Open (or attach to the shared) instance for a kind. */
+  open(kind: SurfaceKind): Promise<OpenSurfaceResult>;
+  /** Route a viewer message to an open instance. No-op if it isn't open. */
+  input(surfaceId: string, msg: SurfaceInputMessage): Promise<void>;
+  /** Resize an open instance. No-op if it isn't open or isn't size-aware. */
+  resize(surfaceId: string, size: SurfaceSize): Promise<void>;
+  /** Close one open instance. */
+  close(surfaceId: string): Promise<void>;
+  /**
+   * Subscribe to outbound frames from EVERY open instance (multiplexed by
+   * `surfaceId`). Returns an unsubscribe fn. The runner subscribes once and
+   * broadcasts each frame as a `surface.data` notification.
+   */
+  onData(cb: (msg: SurfaceDataMessage) => void): () => void;
+  /** Close every open instance (session teardown). */
+  closeAll(): Promise<void>;
+}

package/src/tool-display.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import {
+  diffGutterNo,
+  fileDiffSummary,
+  fileDiffVerb,
+  isFileDiffDisplay,
+  isToolDisplayResult,
+  toDiffRows,
+  type FileDiffDisplay,
+} from './tool-display.js';
+
+const diff = (over: Partial<FileDiffDisplay> = {}): FileDiffDisplay => ({
+  kind: 'file-diff',
+  path: 'src/a.ts',
+  mode: 'update',
+  added: 10,
+  removed: 1,
+  hunks: [],
+  ...over,
+});
+
+describe('fileDiffSummary', () => {
+  it('pluralizes and joins', () => {
+    expect(fileDiffSummary(diff())).toBe('Added 10 lines, removed 1 line');
+  });
+  it('handles add-only / remove-only', () => {
+    expect(fileDiffSummary(diff({ removed: 0 }))).toBe('Added 10 lines');
+    expect(fileDiffSummary(diff({ added: 0, removed: 3 }))).toBe('Removed 3 lines');
+  });
+  it('notes truncation', () => {
+    expect(fileDiffSummary(diff({ truncated: true }))).toContain('truncated');
+  });
+});
+
+describe('fileDiffVerb', () => {
+  it('maps mode to verb', () => {
+    expect(fileDiffVerb(diff({ mode: 'create' }))).toBe('Create');
+    expect(fileDiffVerb(diff({ mode: 'update' }))).toBe('Update');
+  });
+});
+
+describe('diffGutterNo', () => {
+  it('uses old number for deletions, new otherwise', () => {
+    expect(diffGutterNo({ kind: 'del', text: '', oldNo: 5, newNo: undefined })).toBe(5);
+    expect(diffGutterNo({ kind: 'add', text: '', newNo: 7 })).toBe(7);
+    expect(diffGutterNo({ kind: 'context', text: '', oldNo: 3, newNo: 4 })).toBe(4);
+  });
+});
+
+describe('toDiffRows', () => {
+  it('inserts a gap marker between hunks', () => {
+    const d = diff({
+      hunks: [
+        { oldStart: 1, oldLines: 1, newStart: 1, newLines: 1, lines: [{ kind: 'context', text: 'a' }] },
+        { oldStart: 9, oldLines: 1, newStart: 9, newLines: 1, lines: [{ kind: 'context', text: 'b' }] },
+      ],
+    });
+    const rows = toDiffRows(d);
+    expect(rows.map((r) => r.kind)).toEqual(['context', 'gap', 'context']);
+  });
+});
+
+describe('guards', () => {
+  it('isFileDiffDisplay / isToolDisplayResult', () => {
+    expect(isFileDiffDisplay(diff())).toBe(true);
+    expect(isFileDiffDisplay({ kind: 'other' })).toBe(false);
+    expect(isToolDisplayResult({ forModel: 'x', display: diff() })).toBe(true);
+    expect(isToolDisplayResult({ forModel: 'x' })).toBe(false);
+    expect(isToolDisplayResult('wrote 12 chars')).toBe(false);
+  });
+});