@teaflask/assistant 0.3.0 → 0.7.0

package/src/core/tool-error-anchors.ts

@@ -1,17 +0,0 @@
-// The tool-error anchor map: an errored TOOL_CALL_RESULT's `error` extra
-// is the envelope's error.message or the tool's own error text, so the
-// transcript reads this map to light the call's output-error state and
-// pane. One binding of the shared sentence family — see
-// tool-sentence-anchors.ts for the model and the strip-and-lift
-// rationale. The empty string still counts here: presence is the failure
-// signal, and the pane text falls back to the result.
-
-import { toolSentenceAnchorsOf } from "./tool-sentence-anchors.js";
-
-const anchors = toolSentenceAnchorsOf("error", { acceptEmpty: true });
-
-export const EMPTY_TOOL_ERROR_ANCHORS = anchors.empty;
-export const toolCallErrorOf = anchors.sentenceOf;
-export const withToolErrorAnchored = anchors.withAnchored;
-export const wellFormedToolErrorAnchorsOf = anchors.wellFormedOf;
-export const toolErrorRecorder = anchors.recorderOf;

package/src/core/tool-flag-anchors.ts

@@ -1,78 +0,0 @@
-// The boolean tool-flag anchor family, pure of React: one factory behind
-// tool-cancel-anchors and tool-offload-anchors (any later boolean extra
-// too). Each instance maps a TOOL_CALL_RESULT extra that is `true`-or-absent
-// to the toolCallIds carrying it. @ag-ui/client 1.0 strips unknown top-level
-// fields before any subscriber, so the transport lifts the extras into
-// metadata (core/tool-outcome.ts) and the set is the flag's only home on
-// the client.
-
-import type { AgentSubscriber } from "@ag-ui/client";
-
-import { toolOutcomeOf } from "./tool-outcome.js";
-
-export interface ToolFlagAnchors {
-  empty: ReadonlySet<string>;
-  /** Narrow the event's lifted flag field (untyped by contract). Anything
-   *  but the literal true is ignored — the contract's "clients MUST ignore
-   *  events and fields they do not recognize". */
-  flagOf: (event: unknown) => boolean;
-  /** Idempotent anchor merge: replays (and StrictMode's rerun) can deliver
-   *  the same flagged result more than once per mount; a repeat returns the
-   *  set unchanged — identity is the publish gate. */
-  withAnchored: (
-    previous: ReadonlySet<string>,
-    toolCallId: string,
-  ) => ReadonlySet<string>;
-  /** A defensive copy for seeding transcript state from the resume
-   *  store: entries that are not strings are dropped rather than
-   *  rendered (or crashed on) — a dropped anchor reappears on the next
-   *  full replay. */
-  wellFormedOf: (stored: ReadonlySet<string>) => ReadonlySet<string>;
-  /** Records each flagged tool result's toolCallId. */
-  recorderOf: (onAnchored: (toolCallId: string) => void) => AgentSubscriber;
-}
-
-export function toolFlagAnchorsOf(
-  // The closed set of boolean TOOL_CALL_RESULT extras (the contract's
-  // fourth, `error`, carries a sentence, not a flag): a typo here would
-  // compile into an anchor set that silently never matches — the flag's
-  // rendering just stops — so the type refuses anything off the wire.
-  field: "cancelled" | "offloaded" | "truncated",
-): ToolFlagAnchors {
-  function flagOf(event: unknown): boolean {
-    return toolOutcomeOf(event)[field] === true;
-  }
-  return {
-    empty: new Set(),
-    flagOf,
-    withAnchored: (previous, toolCallId) => {
-      if (previous.has(toolCallId)) {
-        return previous;
-      }
-      const next = new Set(previous);
-      next.add(toolCallId);
-      return next;
-    },
-    wellFormedOf: (stored) => {
-      const seeded = new Set<string>();
-      // The narrowing deliberately distrusts the set's own types: this
-      // seam turns a stale shape into a missing anchor, never a crash.
-      const entries = stored as ReadonlySet<unknown>;
-      for (const toolCallId of entries) {
-        if (typeof toolCallId === "string") {
-          seeded.add(toolCallId);
-        }
-      }
-      return seeded;
-    },
-    recorderOf: (onAnchored) => {
-      return {
-        onToolCallResultEvent({ event }) {
-          if (flagOf(event)) {
-            onAnchored(event.toolCallId);
-          }
-        },
-      };
-    },
-  };
-}

package/src/core/tool-offload-anchors.ts

@@ -1,16 +0,0 @@
-// The tool-offload anchor set: an offloaded TOOL_CALL_RESULT's content is
-// the context offloader's model-facing replacement (retrieval guidance,
-// stored-reference lines), not the tool's output, so the transcript reads
-// this set to render the quiet shortened-result line instead. One binding
-// of the shared boolean-flag family — see tool-flag-anchors.ts for the
-// model and the strip-and-lift rationale.
-
-import { toolFlagAnchorsOf } from "./tool-flag-anchors.js";
-
-const anchors = toolFlagAnchorsOf("offloaded");
-
-export const EMPTY_TOOL_OFFLOAD_ANCHORS = anchors.empty;
-export const toolCallOffloadedOf = anchors.flagOf;
-export const withToolOffloadAnchored = anchors.withAnchored;
-export const wellFormedToolOffloadAnchorsOf = anchors.wellFormedOf;
-export const toolOffloadRecorder = anchors.recorderOf;

package/src/core/tool-outcome.ts

@@ -1,115 +0,0 @@
-// The tool-outcome lift: @ag-ui/client 1.0 enforces its event schema
-// between the transport and every subscriber, stripping any top-level field
-// the schema does not know — which is where the serving wire carries a
-// TOOL_CALL_RESULT's five optional extras. Event metadata is open by key
-// and survives enforcement, so the transport moves the extras under
-// teaflask's namespace before the client sees them, and every reader asks
-// the namespace, never the top level. The wire itself is unchanged.
-
-import { EventType } from "@ag-ui/core";
-import type { BaseEvent } from "@ag-ui/core";
-import { map, type Observable } from "rxjs";
-
-const TOOL_OUTCOME_FIELDS = [
-  "error",
-  "refused",
-  "cancelled",
-  "truncated",
-  "offloaded",
-] as const;
-
-type ToolOutcomeField = (typeof TOOL_OUTCOME_FIELDS)[number];
-
-/** The lifted extras, values as the wire sent them: each reader keeps its
- *  own literal check (the sentence families want a string, the flag
- *  families want the literal true). */
-export type ToolOutcome = Partial<Record<ToolOutcomeField, unknown>>;
-
-const NAMESPACE = "teaflask";
-const OUTCOME_KEY = "toolOutcome";
-
-function _record(value: unknown): Record<string, unknown> | null {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-/** A TOOL_CALL_RESULT with its extras moved under
- *  `metadata.teaflask.toolOutcome`; any other event, a result carrying
- *  none, or one whose metadata is present and not an object comes back as
- *  the same reference. */
-export function withToolOutcomeLifted(event: BaseEvent): BaseEvent {
-  if (event.type !== EventType.TOOL_CALL_RESULT) {
-    return event;
-  }
-  const source: Record<string, unknown> = event;
-  const lifted: Record<string, unknown> = {};
-  for (const field of TOOL_OUTCOME_FIELDS) {
-    if (Object.prototype.hasOwnProperty.call(source, field)) {
-      lifted[field] = source[field];
-    }
-  }
-  if (Object.keys(lifted).length === 0) {
-    return event;
-  }
-  const rest: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(source)) {
-    if (!(TOOL_OUTCOME_FIELDS as readonly string[]).includes(key)) {
-      rest[key] = value;
-    }
-  }
-  // Metadata the protocol would reject — present and not an object — is
-  // left exactly as sent: the client's validator, not the lift, decides
-  // what becomes of it. Inside a valid object the teaflask namespace is
-  // this package's own: a value there that is not an object was never
-  // written by this package and never read by anything, and the wire's
-  // extras must survive, so the lift takes the namespace over rather than
-  // letting the extras be stripped in silence.
-  const metadata =
-    source.metadata === undefined ? {} : _record(source.metadata);
-  if (metadata === null) {
-    return event;
-  }
-  const namespace = _record(metadata[NAMESPACE]) ?? {};
-  const outcome = _record(namespace[OUTCOME_KEY]) ?? {};
-  rest.metadata = {
-    ...metadata,
-    [NAMESPACE]: {
-      ...namespace,
-      [OUTCOME_KEY]: { ...outcome, ...lifted },
-    },
-  };
-  return rest as unknown as BaseEvent;
-}
-
-/** The lifted extras of an event — empty for anything that carries none,
- *  a non-object, or extras left on the top level (enforcement would have
- *  dropped those; reading them here would report a state the pipeline
- *  never delivers). */
-export function toolOutcomeOf(event: unknown): ToolOutcome {
-  const source = _record(event);
-  if (source === null) {
-    return {};
-  }
-  const namespace = _record(_record(source.metadata)?.[NAMESPACE]);
-  const outcome = _record(namespace?.[OUTCOME_KEY]);
-  if (outcome === null) {
-    return {};
-  }
-  const result: ToolOutcome = {};
-  for (const field of TOOL_OUTCOME_FIELDS) {
-    if (Object.prototype.hasOwnProperty.call(outcome, field)) {
-      result[field] = outcome[field];
-    }
-  }
-  return result;
-}
-
-/** The transport seam: pipe a run's events through the lift before the
- *  client enforces its schema. A plain function over the Observable so a
- *  host agent needs no rxjs import of its own. */
-export function liftToolOutcome(
-  events$: Observable<BaseEvent>,
-): Observable<BaseEvent> {
-  return events$.pipe(map(withToolOutcomeLifted));
-}

package/src/core/tool-refusal-anchors.ts

@@ -1,18 +0,0 @@
-// The tool-refusal anchor map: a refused TOOL_CALL_RESULT's
-// `refused` extra is the door's own refusal sentence — a door that
-// answered and declined — so the transcript reads this map to light the
-// call's refused state and show the sentence as the row's reason. One
-// binding of the shared sentence family — see tool-sentence-anchors.ts
-// for the model and the strip-and-lift rationale. Only a non-empty
-// string counts here: the sentence IS the reason the row shows, and the
-// mapper never stamps an empty one.
-
-import { toolSentenceAnchorsOf } from "./tool-sentence-anchors.js";
-
-const anchors = toolSentenceAnchorsOf("refused", { acceptEmpty: false });
-
-export const EMPTY_TOOL_REFUSAL_ANCHORS = anchors.empty;
-export const toolCallRefusalOf = anchors.sentenceOf;
-export const withToolRefusalAnchored = anchors.withAnchored;
-export const wellFormedToolRefusalAnchorsOf = anchors.wellFormedOf;
-export const toolRefusalRecorder = anchors.recorderOf;

package/src/core/tool-result-envelope.ts

@@ -1,63 +0,0 @@
-/**
- * The tool-result/v1 envelope parser, rescued from the retired ui_spec
- * result grammar. The producer is the action adapter's
- * ExecutionOutcome ({ok: true, result} with http_intent results shaped
- * {status, headers, body, truncated}); the consumer is the tool-view
- * call assembly: toolCallPresentationOf parses `resultText`
- * through here into `call.result`, with the null refusal surfacing as
- * the call's honest `truncated` flag.
- */
-
-/**
- * The renderable payload: a tool-result/v1 success envelope unwrapped —
- * protocol knowledge, which the package may hold; a customer's catalog
- * it may not — and every other document passed through untouched. Null refuses
- * the result entirely: a body the client degraded to fit the size cap
- * (truncated) must never structure, since a complete-looking component
- * over a cut payload is a wrong claim. The envelope check is exact-keys
- * ({ok, result} and nothing else, ok === true) so an arbitrary payload
- * that merely mentions ok can never misfire the unwrap; a failure
- * envelope carries a third key (instruction) and never matches. The
- * {payload} box distinguishes a legitimately null-ish payload from the
- * refusal.
- */
-export function toolResultEnvelopePayloadOf(
-  parsed: unknown,
-): { payload: unknown } | null {
-  if (!_isRecord(parsed)) {
-    return { payload: parsed };
-  }
-  const keys = Object.keys(parsed);
-  const envelopeShaped =
-    keys.length === 2 &&
-    _hasOwn(parsed, "ok") &&
-    _hasOwn(parsed, "result") &&
-    parsed.ok === true &&
-    _isRecord(parsed.result);
-  if (!envelopeShaped) {
-    return { payload: parsed };
-  }
-  const result = parsed.result as Record<string, unknown>;
-  if (result.truncated === true) {
-    return null;
-  }
-  // http_intent-shaped: the customer's response JSON rides in body, the
-  // transport facts (status, headers) around it are not the data.
-  if (typeof result.status === "number" && _hasOwn(result, "body")) {
-    return { payload: result.body };
-  }
-  return { payload: result };
-}
-
-/** Own-key membership, never the prototype chain: result keys arrive
- *  from customer payloads, so a key naming an Object.prototype member
- *  (constructor, toString, …) must read as data and nothing more.
- *  (hasOwnProperty.call, not Object.hasOwn — the dashboard's TS lib
- *  predates ES2022.) */
-function _hasOwn(record: Record<string, unknown>, key: string): boolean {
-  return Object.prototype.hasOwnProperty.call(record, key);
-}
-
-function _isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/core/tool-schema-anchors.ts

@@ -1,207 +0,0 @@
-// The tool-schema anchor model, pure of React: the recorder
-// maps each tool_call_annotated CUSTOM marker's schema siblings to its
-// toolCallId, the presenter reads the map to hand a mounted view its
-// `argsSchema` / `resultSchema`, and the resume store holds the map
-// across remounts. Same indirection as the display anchors — a CUSTOM
-// marker never becomes a message, so this map is the schemas' only
-// client home — plus one more feed: the approval card's
-// toolInputSchema / toolOutputSchema (the `approval_requested` marker
-// and the REST turn record's pending_approvals both build cards), so a
-// paused-then-denied call that never ran still knows its shape.
-//
-// Deliberately uncapped, unlike the display sentences' 500-char clip: a
-// clipped JSON Schema is a syntactically broken lie, not a degraded
-// sentence, and the source is the operator-reviewed catalog row the
-// approval channel already carries whole. The narrower guards shape
-// only — a plain non-array record or absent, never a fabricated `{}`.
-
-import type { AgentSubscriber } from "@ag-ui/client";
-
-import { TOOL_CALL_ANNOTATED_EVENT_NAME } from "../contract/events.js";
-import type { JsonSchema } from "./tool-view.js";
-
-/** One call's anchored schemas. Either field may be absent — a tool
- *  registers each schema independently, and absence rides through. */
-export interface ToolCallSchemas {
-  argsSchema?: JsonSchema;
-  resultSchema?: JsonSchema;
-}
-
-export const EMPTY_TOOL_SCHEMA_ANCHORS: ReadonlyMap<string, ToolCallSchemas> =
-  new Map();
-
-/**
- * Narrow a tool_call_annotated marker's schema siblings. Null means the
- * marker anchors no schema — a display-only annotation (the common
- * completion emission), a null field (an explicit "none"), or a
- * malformed one all leave this map untouched; the display narrower owns
- * the display half independently, so neither half's absence gates the
- * other.
- */
-export function toolSchemaAnchorOf(
-  value: unknown,
-): { toolCallId: string; schemas: ToolCallSchemas } | null {
-  if (typeof value !== "object" || value === null) {
-    return null;
-  }
-  const {
-    tool_call_id: toolCallId,
-    tool_input_schema,
-    tool_output_schema,
-  } = value as {
-    tool_call_id?: unknown;
-    tool_input_schema?: unknown;
-    tool_output_schema?: unknown;
-  };
-  if (typeof toolCallId !== "string" || toolCallId === "") {
-    return null;
-  }
-  const schemas: ToolCallSchemas = {};
-  const argsSchema = _schemaOf(tool_input_schema);
-  if (argsSchema !== undefined) {
-    schemas.argsSchema = argsSchema;
-  }
-  const resultSchema = _schemaOf(tool_output_schema);
-  if (resultSchema !== undefined) {
-    schemas.resultSchema = resultSchema;
-  }
-  if (schemas.argsSchema === undefined && schemas.resultSchema === undefined) {
-    return null;
-  }
-  return { toolCallId, schemas };
-}
-
-/**
- * Idempotent per-field merge, first non-absent value wins: the schemas
- * legitimately arrive more than once for one call (the approval card's
- * feed for a paused call, then the progress annotation once it runs,
- * then every replay again), and re-applying the same sequence changes
- * nothing. A no-op merge returns the map unchanged — identity is the
- * publish gate — and a merged entry keeps the previously stored field
- * REFERENCES, so a schema handed to a mounted view stays
- * identity-stable across re-records (the slot's delivery guard compares
- * `===`).
- */
-export function withToolSchemasAnchored(
-  previous: ReadonlyMap<string, ToolCallSchemas>,
-  toolCallId: string,
-  schemas: ToolCallSchemas,
-): ReadonlyMap<string, ToolCallSchemas> {
-  const existing = previous.get(toolCallId);
-  if (existing === undefined) {
-    const next = new Map(previous);
-    next.set(toolCallId, schemas);
-    return next;
-  }
-  if (
-    (existing.argsSchema !== undefined || schemas.argsSchema === undefined) &&
-    (existing.resultSchema !== undefined || schemas.resultSchema === undefined)
-  ) {
-    return previous;
-  }
-  const merged: ToolCallSchemas = {};
-  const argsSchema = existing.argsSchema ?? schemas.argsSchema;
-  if (argsSchema !== undefined) {
-    merged.argsSchema = argsSchema;
-  }
-  const resultSchema = existing.resultSchema ?? schemas.resultSchema;
-  if (resultSchema !== undefined) {
-    merged.resultSchema = resultSchema;
-  }
-  const next = new Map(previous);
-  next.set(toolCallId, merged);
-  return next;
-}
-
-/**
- * A defensive re-validation for seeding transcript state from the
- * resume store, like every sibling anchors map: an entry that is not a
- * string-keyed record of plain-record schemas is dropped rather than
- * rendered (or crashed on) — a stale shape becomes a missing schema,
- * never a wedged resume.
- */
-export function wellFormedToolSchemaAnchorsOf(
-  stored: ReadonlyMap<string, ToolCallSchemas>,
-): ReadonlyMap<string, ToolCallSchemas> {
-  const seeded = new Map<string, ToolCallSchemas>();
-  // The narrowing deliberately distrusts the map's own types (the seam
-  // where any future persisted form of the store must degrade).
-  const entries = stored as ReadonlyMap<unknown, unknown>;
-  for (const [toolCallId, schemas] of entries) {
-    if (typeof toolCallId !== "string" || !_isWellFormedSchemas(schemas)) {
-      continue;
-    }
-    seeded.set(toolCallId, schemas);
-  }
-  return seeded;
-}
-
-/** Records each annotated call's toolCallId → registered schemas. */
-export function toolSchemaRecorder(
-  onSchemasAnchored: (toolCallId: string, schemas: ToolCallSchemas) => void,
-): AgentSubscriber {
-  return {
-    onCustomEvent({ event }) {
-      if (event.name !== TOOL_CALL_ANNOTATED_EVENT_NAME) {
-        return;
-      }
-      const anchor = toolSchemaAnchorOf(event.value);
-      if (anchor !== null) {
-        onSchemasAnchored(anchor.toolCallId, anchor.schemas);
-      }
-    },
-  };
-}
-
-/**
- * The approval card's schemas as an anchorable record — the null→absent
- * seam for the channel's other producer. The card model is the single
- * already-narrowed home of the `approval_requested` marker's
- * tool_input_schema / tool_output_schema (stream AND the REST turn
- * record's pending_approvals — approval-inbox.ts), so this consumes the
- * built card rather than re-narrowing the wire a second time. Null on a
- * card that carries neither schema.
- */
-export function approvalCardSchemasOf(card: {
-  toolInputSchema: Record<string, unknown> | null;
-  toolOutputSchema: Record<string, unknown> | null;
-}): ToolCallSchemas | null {
-  if (card.toolInputSchema === null && card.toolOutputSchema === null) {
-    return null;
-  }
-  const schemas: ToolCallSchemas = {};
-  if (card.toolInputSchema !== null) {
-    schemas.argsSchema = card.toolInputSchema;
-  }
-  if (card.toolOutputSchema !== null) {
-    schemas.resultSchema = card.toolOutputSchema;
-  }
-  return schemas;
-}
-
-/** A schema is a plain non-array record, verbatim; anything else —
- *  null, an array, a string — is absent, never a crash and never `{}`
- *  invented from a malformed value. */
-function _schemaOf(schema: unknown): JsonSchema | undefined {
-  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
-    return undefined;
-  }
-  return schema as JsonSchema;
-}
-
-function _isWellFormedSchemas(schemas: unknown): schemas is ToolCallSchemas {
-  if (typeof schemas !== "object" || schemas === null) {
-    return false;
-  }
-  const { argsSchema, resultSchema } = schemas as {
-    argsSchema?: unknown;
-    resultSchema?: unknown;
-  };
-  const fieldsAreWellTypedOrAbsent =
-    (argsSchema === undefined || _schemaOf(argsSchema) !== undefined) &&
-    (resultSchema === undefined || _schemaOf(resultSchema) !== undefined);
-  return (
-    fieldsAreWellTypedOrAbsent &&
-    (argsSchema !== undefined || resultSchema !== undefined)
-  );
-}

package/src/core/tool-sentence-anchors.ts

@@ -1,104 +0,0 @@
-// The sentence-carrying tool-result anchor family, pure of React: one
-// factory behind tool-error-anchors and tool-refusal-anchors (the
-// sibling of tool-flag-anchors' boolean family). Each instance maps
-// a TOOL_CALL_RESULT extra that carries a server-derived sentence to the
-// toolCallIds carrying it: the recorder collects sentences from the live
-// stream, the transcript reads the map to light a call's state and show
-// the sentence, and the resume store holds the map across remounts. The
-// indirection exists because @ag-ui/client 1.0 strips unknown top-level
-// fields before any subscriber — the transport lifts the extras into
-// metadata (core/tool-outcome.ts), and the map is the sentence's only home
-// on the client. The two bindings differ in exactly one rule, stated at
-// the factory's door: whether the empty string counts.
-
-import type { AgentSubscriber } from "@ag-ui/client";
-
-import { toolOutcomeOf } from "./tool-outcome.js";
-import { WIRE_SENTENCE_MAX_CHARS } from "./wire-sentence-cap.js";
-
-export interface ToolSentenceAnchors {
-  empty: ReadonlyMap<string, string>;
-  /** Narrow the event's lifted sentence field (untyped by contract). A non-string is ignored — the
-   *  contract's "clients MUST ignore events and fields they do not
-   *  recognize"; the sentence is retained capped, never unbounded. */
-  sentenceOf: (event: unknown) => string | null;
-  /** Idempotent anchor merge: every connection replays the stream from
-   *  its boundary (and StrictMode aborts and reruns the first
-   *  connection), so the same result can arrive more than once per
-   *  mount. First anchor wins, and a repeat returns the map unchanged —
-   *  identity is the publish gate. */
-  withAnchored: (
-    previous: ReadonlyMap<string, string>,
-    toolCallId: string,
-    sentence: string,
-  ) => ReadonlyMap<string, string>;
-  /** A defensive copy for seeding transcript state from the resume
-   *  store: entries that are not string→string are dropped rather than
-   *  rendered (or crashed on) — a dropped sentence reappears on the next
-   *  full replay. */
-  wellFormedOf: (
-    stored: ReadonlyMap<string, string>,
-  ) => ReadonlyMap<string, string>;
-  /** Records each matching tool result's toolCallId → sentence. */
-  recorderOf: (
-    onAnchored: (toolCallId: string, sentence: string) => void,
-  ) => AgentSubscriber;
-}
-
-export function toolSentenceAnchorsOf(
-  // The closed set of sentence-carrying TOOL_CALL_RESULT extras: a typo
-  // here would compile into a map that silently never fills, so the type
-  // refuses anything off the wire.
-  field: "error" | "refused",
-  options: {
-    /** Whether "" is a sentence. `error`: yes — presence is the failure
-     *  signal and the pane text falls back to the result. `refused`: no —
-     *  the sentence IS the reason the row shows, never stamped empty. */
-    acceptEmpty: boolean;
-  },
-): ToolSentenceAnchors {
-  function sentenceOf(event: unknown): string | null {
-    const value = toolOutcomeOf(event)[field];
-    if (typeof value !== "string") {
-      return null;
-    }
-    if (value === "" && !options.acceptEmpty) {
-      return null;
-    }
-    return value.slice(0, WIRE_SENTENCE_MAX_CHARS);
-  }
-  return {
-    empty: new Map(),
-    sentenceOf,
-    withAnchored: (previous, toolCallId, sentence) => {
-      if (previous.has(toolCallId)) {
-        return previous;
-      }
-      const next = new Map(previous);
-      next.set(toolCallId, sentence);
-      return next;
-    },
-    wellFormedOf: (stored) => {
-      const seeded = new Map<string, string>();
-      // The narrowing deliberately distrusts the map's own types: this
-      // seam turns a stale shape into a missing sentence, never a crash.
-      const entries = stored as ReadonlyMap<unknown, unknown>;
-      for (const [toolCallId, sentence] of entries) {
-        if (typeof toolCallId === "string" && typeof sentence === "string") {
-          seeded.set(toolCallId, sentence);
-        }
-      }
-      return seeded;
-    },
-    recorderOf: (onAnchored) => {
-      return {
-        onToolCallResultEvent({ event }) {
-          const sentence = sentenceOf(event);
-          if (sentence !== null) {
-            onAnchored(event.toolCallId, sentence);
-          }
-        },
-      };
-    },
-  };
-}