@teaflask/assistant 0.3.0 → 0.6.0

package/dist/core/tool-denial-anchors.d.ts

@@ -1,20 +1,10 @@
 import type { AgentSubscriber } from "@ag-ui/client";
-/**
- * The ledger's two halves: the ask map (interrupt id → the tool call an
- * approval_requested named) and the denied set (tool call ids whose ask
- * was answered approved:false). Only `denied` is presentation — the
- * snapshot exposes it alone as `toolDenialAnchors`; `asks` exists so the
- * fold can join a later resolution.
- */
 export interface ToolDenialLedger {
     asks: ReadonlyMap<string, string>;
     denied: ReadonlySet<string>;
 }
 export declare const EMPTY_TOOL_DENIAL_LEDGER: ToolDenialLedger;
-/** The presentation half's empty value — what the projection reads when
- *  a snapshot carries no ledger at all. */
 export declare const EMPTY_TOOL_DENIAL_ANCHORS: ReadonlySet<string>;
-/** A narrowed marker the ledger folds: an ask, or a denial. */
 export type ToolDenialMarker = {
     kind: "ask";
     interruptId: string;
@@ -23,36 +13,7 @@ export type ToolDenialMarker = {
     kind: "denied";
     interruptId: string;
 };
-/**
- * Narrow a CUSTOM event to the marker the ledger folds, or null: an
- * approval_requested carrying both a non-empty interrupt_id and a
- * non-empty tool_call_id (an unanchored ask — a wire that named no call
- * — marks nothing: there is no row to reclassify), or an
- * approval_resolved whose `approved` is false. An approval is not a
- * marker here (the call then runs, and its own result tells its story).
- * Anything malformed is ignored — the contract's "clients MUST ignore
- * events and fields they do not recognize".
- */
 export declare function toolDenialMarkerOf(name: string, value: unknown): ToolDenialMarker | null;
-/**
- * The idempotent fold: every connection replays the stream from its
- * boundary (and StrictMode aborts and reruns the first connection), so
- * the same marker can arrive more than once per mount. A repeat — an
- * ask already held, a denial already recorded — returns the ledger
- * unchanged, and so does a denial whose interrupt no held ask names
- * (premise 2). Otherwise the changed half is rebuilt and the untouched
- * half keeps its identity: `denied`'s identity is the publish gate, so
- * an ask alone never repaints the transcript.
- */
 export declare function withToolDenialMarkerFolded(ledger: ToolDenialLedger, marker: ToolDenialMarker): ToolDenialLedger;
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * non-string members are dropped rather than rendered (or crashed on) —
- * a dropped anchor reappears on the next full replay.
- */
 export declare function wellFormedToolDenialAnchorsOf(stored: ReadonlySet<string>): ReadonlySet<string>;
-/** Records the two approval markers, narrowed — CUSTOM events only; this
- *  recorder never reads a tool result (the cancelled stamp it
- *  reclassifies rides tool-cancel-anchors.ts, one rung below). */
 export declare function toolDenialRecorder(onMarker: (marker: ToolDenialMarker) => void): AgentSubscriber;
-//# sourceMappingURL=tool-denial-anchors.d.ts.map

package/dist/core/tool-denial-anchors.js

@@ -1,27 +1,10 @@
-// The tool-denial ledger: the durable record that a member
-// DECLINED the approval a call was paused for, keyed by tool_call_id. The
-// wire stamps a denial `cancelled`, so the state is a client-side JOIN of
-// the approval_requested and approval_resolved markers that reclassifies
-// that stamp. The ordering premises: docs/decision-anchors.md.
 import { APPROVAL_REQUESTED_EVENT_NAME, APPROVAL_RESOLVED_EVENT_NAME, } from "../contract/events.js";
 import { approvalResolvedPayloadOf } from "./approval-resolved.js";
 export const EMPTY_TOOL_DENIAL_LEDGER = {
     asks: new Map(),
     denied: new Set(),
 };
-/** The presentation half's empty value — what the projection reads when
- *  a snapshot carries no ledger at all. */
 export const EMPTY_TOOL_DENIAL_ANCHORS = EMPTY_TOOL_DENIAL_LEDGER.denied;
-/**
- * Narrow a CUSTOM event to the marker the ledger folds, or null: an
- * approval_requested carrying both a non-empty interrupt_id and a
- * non-empty tool_call_id (an unanchored ask — a wire that named no call
- * — marks nothing: there is no row to reclassify), or an
- * approval_resolved whose `approved` is false. An approval is not a
- * marker here (the call then runs, and its own result tells its story).
- * Anything malformed is ignored — the contract's "clients MUST ignore
- * events and fields they do not recognize".
- */
 export function toolDenialMarkerOf(name, value) {
     if (name === APPROVAL_REQUESTED_EVENT_NAME) {
         if (typeof value !== "object" || value === null) {
@@ -47,16 +30,6 @@ export function toolDenialMarkerOf(name, value) {
     }
     return null;
 }
-/**
- * The idempotent fold: every connection replays the stream from its
- * boundary (and StrictMode aborts and reruns the first connection), so
- * the same marker can arrive more than once per mount. A repeat — an
- * ask already held, a denial already recorded — returns the ledger
- * unchanged, and so does a denial whose interrupt no held ask names
- * (premise 2). Otherwise the changed half is rebuilt and the untouched
- * half keeps its identity: `denied`'s identity is the publish gate, so
- * an ask alone never repaints the transcript.
- */
 export function withToolDenialMarkerFolded(ledger, marker) {
     if (marker.kind === "ask") {
         if (ledger.asks.has(marker.interruptId)) {
@@ -74,11 +47,6 @@ export function withToolDenialMarkerFolded(ledger, marker) {
     denied.add(toolCallId);
     return { asks: ledger.asks, denied };
 }
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * non-string members are dropped rather than rendered (or crashed on) —
- * a dropped anchor reappears on the next full replay.
- */
 export function wellFormedToolDenialAnchorsOf(stored) {
     const seeded = new Set();
     for (const toolCallId of stored) {
@@ -88,9 +56,6 @@ export function wellFormedToolDenialAnchorsOf(stored) {
     }
     return seeded;
 }
-/** Records the two approval markers, narrowed — CUSTOM events only; this
- *  recorder never reads a tool result (the cancelled stamp it
- *  reclassifies rides tool-cancel-anchors.ts, one rung below). */
 export function toolDenialRecorder(onMarker) {
     return {
         onCustomEvent({ event }) {
@@ -101,4 +66,3 @@ export function toolDenialRecorder(onMarker) {
         },
     };
 }
-//# sourceMappingURL=tool-denial-anchors.js.map

package/dist/core/tool-error-anchors.d.ts

@@ -3,4 +3,3 @@ export declare const toolCallErrorOf: (event: unknown) => string | null;
 export declare const withToolErrorAnchored: (previous: ReadonlyMap<string, string>, toolCallId: string, sentence: string) => ReadonlyMap<string, string>;
 export declare const wellFormedToolErrorAnchorsOf: (stored: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
 export declare const toolErrorRecorder: (onAnchored: (toolCallId: string, sentence: string) => void) => import("@ag-ui/client").AgentSubscriber;
-//# sourceMappingURL=tool-error-anchors.d.ts.map

package/dist/core/tool-error-anchors.js

@@ -1,10 +1,3 @@
-// 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;
@@ -12,4 +5,3 @@ export const toolCallErrorOf = anchors.sentenceOf;
 export const withToolErrorAnchored = anchors.withAnchored;
 export const wellFormedToolErrorAnchorsOf = anchors.wellFormedOf;
 export const toolErrorRecorder = anchors.recorderOf;
-//# sourceMappingURL=tool-error-anchors.js.map

package/dist/core/tool-flag-anchors.d.ts

@@ -1,21 +1,9 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 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 declare function toolFlagAnchorsOf(field: "cancelled" | "offloaded" | "truncated"): ToolFlagAnchors;
-//# sourceMappingURL=tool-flag-anchors.d.ts.map

package/dist/core/tool-flag-anchors.js

@@ -1,17 +1,5 @@
-// 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 { toolOutcomeOf } from "./tool-outcome.js";
-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) {
+export function toolFlagAnchorsOf(field) {
     function flagOf(event) {
         return toolOutcomeOf(event)[field] === true;
     }
@@ -28,8 +16,6 @@ field) {
         },
         wellFormedOf: (stored) => {
             const seeded = new Set();
-            // 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;
             for (const toolCallId of entries) {
                 if (typeof toolCallId === "string") {
@@ -49,4 +35,3 @@ field) {
         },
     };
 }
-//# sourceMappingURL=tool-flag-anchors.js.map

package/dist/core/tool-offload-anchors.d.ts

@@ -3,4 +3,3 @@ export declare const toolCallOffloadedOf: (event: unknown) => boolean;
 export declare const withToolOffloadAnchored: (previous: ReadonlySet<string>, toolCallId: string) => ReadonlySet<string>;
 export declare const wellFormedToolOffloadAnchorsOf: (stored: ReadonlySet<string>) => ReadonlySet<string>;
 export declare const toolOffloadRecorder: (onAnchored: (toolCallId: string) => void) => import("@ag-ui/client").AgentSubscriber;
-//# sourceMappingURL=tool-offload-anchors.d.ts.map

package/dist/core/tool-offload-anchors.js

@@ -1,9 +1,3 @@
-// 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;
@@ -11,4 +5,3 @@ export const toolCallOffloadedOf = anchors.flagOf;
 export const withToolOffloadAnchored = anchors.withAnchored;
 export const wellFormedToolOffloadAnchorsOf = anchors.wellFormedOf;
 export const toolOffloadRecorder = anchors.recorderOf;
-//# sourceMappingURL=tool-offload-anchors.js.map

package/dist/core/tool-outcome.d.ts

@@ -2,23 +2,8 @@ import type { BaseEvent } from "@ag-ui/core";
 import { type Observable } from "rxjs";
 declare const TOOL_OUTCOME_FIELDS: readonly ["error", "refused", "cancelled", "truncated", "offloaded"];
 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>>;
-/** 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 declare function withToolOutcomeLifted(event: BaseEvent): 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 declare function toolOutcomeOf(event: unknown): ToolOutcome;
-/** 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 declare function liftToolOutcome(events$: Observable<BaseEvent>): Observable<BaseEvent>;
 export {};
-//# sourceMappingURL=tool-outcome.d.ts.map

package/dist/core/tool-outcome.js

@@ -1,10 +1,3 @@
-// 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 { map } from "rxjs";
 const TOOL_OUTCOME_FIELDS = [
@@ -21,10 +14,6 @@ function _record(value) {
         ? value
         : 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) {
     if (event.type !== EventType.TOOL_CALL_RESULT) {
         return event;
@@ -45,13 +34,6 @@ export function withToolOutcomeLifted(event) {
             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;
@@ -67,10 +49,6 @@ export function withToolOutcomeLifted(event) {
     };
     return rest;
 }
-/** 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) {
     const source = _record(event);
     if (source === null) {
@@ -89,10 +67,6 @@ export function toolOutcomeOf(event) {
     }
     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$) {
     return events$.pipe(map(withToolOutcomeLifted));
 }
-//# sourceMappingURL=tool-outcome.js.map

package/dist/core/tool-refusal-anchors.d.ts

@@ -3,4 +3,3 @@ export declare const toolCallRefusalOf: (event: unknown) => string | null;
 export declare const withToolRefusalAnchored: (previous: ReadonlyMap<string, string>, toolCallId: string, sentence: string) => ReadonlyMap<string, string>;
 export declare const wellFormedToolRefusalAnchorsOf: (stored: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
 export declare const toolRefusalRecorder: (onAnchored: (toolCallId: string, sentence: string) => void) => import("@ag-ui/client").AgentSubscriber;
-//# sourceMappingURL=tool-refusal-anchors.d.ts.map

package/dist/core/tool-refusal-anchors.js

@@ -1,11 +1,3 @@
-// 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;
@@ -13,4 +5,3 @@ export const toolCallRefusalOf = anchors.sentenceOf;
 export const withToolRefusalAnchored = anchors.withAnchored;
 export const wellFormedToolRefusalAnchorsOf = anchors.wellFormedOf;
 export const toolRefusalRecorder = anchors.recorderOf;
-//# sourceMappingURL=tool-refusal-anchors.js.map

package/dist/core/tool-result-envelope.d.ts

@@ -1,26 +1,3 @@
-/**
- * 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 declare function toolResultEnvelopePayloadOf(parsed: unknown): {
     payload: unknown;
 } | null;
-//# sourceMappingURL=tool-result-envelope.d.ts.map

package/dist/core/tool-result-envelope.js

@@ -1,25 +1,3 @@
-/**
- * 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) {
     if (!_isRecord(parsed)) {
         return { payload: parsed };
@@ -37,22 +15,14 @@ export function toolResultEnvelopePayloadOf(parsed) {
     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, key) {
     return Object.prototype.hasOwnProperty.call(record, key);
 }
 function _isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=tool-result-envelope.js.map

package/dist/core/tool-schema-anchors.d.ts

@@ -1,57 +1,18 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 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 declare const EMPTY_TOOL_SCHEMA_ANCHORS: ReadonlyMap<string, ToolCallSchemas>;
-/**
- * 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 declare function toolSchemaAnchorOf(value: unknown): {
     toolCallId: string;
     schemas: ToolCallSchemas;
 } | null;
-/**
- * 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 declare function withToolSchemasAnchored(previous: ReadonlyMap<string, ToolCallSchemas>, toolCallId: string, schemas: ToolCallSchemas): ReadonlyMap<string, ToolCallSchemas>;
-/**
- * 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 declare function wellFormedToolSchemaAnchorsOf(stored: ReadonlyMap<string, ToolCallSchemas>): ReadonlyMap<string, ToolCallSchemas>;
-/** Records each annotated call's toolCallId → registered schemas. */
 export declare function toolSchemaRecorder(onSchemasAnchored: (toolCallId: string, schemas: ToolCallSchemas) => void): AgentSubscriber;
-/**
- * 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 declare function approvalCardSchemasOf(card: {
     toolInputSchema: Record<string, unknown> | null;
     toolOutputSchema: Record<string, unknown> | null;
 }): ToolCallSchemas | null;
-//# sourceMappingURL=tool-schema-anchors.d.ts.map

package/dist/core/tool-schema-anchors.js

@@ -1,29 +1,5 @@
-// 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 { TOOL_CALL_ANNOTATED_EVENT_NAME } from "../contract/events.js";
 export const EMPTY_TOOL_SCHEMA_ANCHORS = 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) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -46,17 +22,6 @@ export function toolSchemaAnchorOf(value) {
     }
     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, toolCallId, schemas) {
     const existing = previous.get(toolCallId);
     if (existing === undefined) {
@@ -81,17 +46,8 @@ export function withToolSchemasAnchored(previous, toolCallId, schemas) {
     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) {
     const seeded = new Map();
-    // The narrowing deliberately distrusts the map's own types (the seam
-    // where any future persisted form of the store must degrade).
     const entries = stored;
     for (const [toolCallId, schemas] of entries) {
         if (typeof toolCallId !== "string" || !_isWellFormedSchemas(schemas)) {
@@ -101,7 +57,6 @@ export function wellFormedToolSchemaAnchorsOf(stored) {
     }
     return seeded;
 }
-/** Records each annotated call's toolCallId → registered schemas. */
 export function toolSchemaRecorder(onSchemasAnchored) {
     return {
         onCustomEvent({ event }) {
@@ -115,15 +70,6 @@ export function toolSchemaRecorder(onSchemasAnchored) {
         },
     };
 }
-/**
- * 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) {
     if (card.toolInputSchema === null && card.toolOutputSchema === null) {
         return null;
@@ -137,9 +83,6 @@ export function approvalCardSchemasOf(card) {
     }
     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) {
     if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
         return undefined;
@@ -156,4 +99,3 @@ function _isWellFormedSchemas(schemas) {
     return (fieldsAreWellTypedOrAbsent &&
         (argsSchema !== undefined || resultSchema !== undefined));
 }
-//# sourceMappingURL=tool-schema-anchors.js.map

package/dist/core/tool-sentence-anchors.d.ts

@@ -1,28 +1,11 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 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 declare function toolSentenceAnchorsOf(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;
-//# sourceMappingURL=tool-sentence-anchors.d.ts.map

package/dist/core/tool-sentence-anchors.js

@@ -1,22 +1,6 @@
-// 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 { toolOutcomeOf } from "./tool-outcome.js";
 import { WIRE_SENTENCE_MAX_CHARS } from "./wire-sentence-cap.js";
-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, options) {
+export function toolSentenceAnchorsOf(field, options) {
     function sentenceOf(event) {
         const value = toolOutcomeOf(event)[field];
         if (typeof value !== "string") {
@@ -40,8 +24,6 @@ field, options) {
         },
         wellFormedOf: (stored) => {
             const seeded = new Map();
-            // 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;
             for (const [toolCallId, sentence] of entries) {
                 if (typeof toolCallId === "string" && typeof sentence === "string") {
@@ -62,4 +44,3 @@ field, options) {
         },
     };
 }
-//# sourceMappingURL=tool-sentence-anchors.js.map