@teaflask/assistant 0.0.0 → 0.3.0

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

@@ -0,0 +1,6 @@
+export declare const EMPTY_TOOL_REFUSAL_ANCHORS: ReadonlyMap<string, string>;
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-refusal-anchors.d.ts","sourceRoot":"","sources":["../../src/core/tool-refusal-anchors.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,0BAA0B,6BAAgB,CAAC;AACxD,eAAO,MAAM,iBAAiB,mCAAqB,CAAC;AACpD,eAAO,MAAM,uBAAuB,8GAAuB,CAAC;AAC5D,eAAO,MAAM,8BAA8B,sEAAuB,CAAC;AACnE,eAAO,MAAM,mBAAmB,yGAAqB,CAAC"}

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

@@ -0,0 +1,16 @@
+// 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;
+//# sourceMappingURL=tool-refusal-anchors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-refusal-anchors.js","sourceRoot":"","sources":["../../src/core/tool-refusal-anchors.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,mEAAmE;AACnE,wEAAwE;AACxE,sEAAsE;AACtE,uEAAuE;AACvE,mEAAmE;AACnE,wEAAwE;AACxE,oCAAoC;AAEpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,OAAO,GAAG,qBAAqB,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,0BAA0B,GAAG,OAAO,CAAC,KAAK,CAAC;AACxD,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;AACpD,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC,YAAY,CAAC;AAC5D,MAAM,CAAC,MAAM,8BAA8B,GAAG,OAAO,CAAC,YAAY,CAAC;AACnE,MAAM,CAAC,MAAM,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-envelope.d.ts","sourceRoot":"","sources":["../../src/core/tool-result-envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,GACd;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAwB7B"}

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

@@ -0,0 +1,58 @@
+/**
+ * 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 };
+    }
+    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;
+    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-result-envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result-envelope.js","sourceRoot":"","sources":["../../src/core/tool-result-envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAe;IAEf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAC7B,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjC,MAAM,cAAc,GAClB,IAAI,CAAC,MAAM,KAAK,CAAC;QACjB,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC;QACrB,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC;QACzB,MAAM,CAAC,EAAE,KAAK,IAAI;QAClB,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC3B,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAC7B,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAiC,CAAC;IACxD,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,sEAAsE;IACtE,gEAAgE;IAChE,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;QACjE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;IAClC,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC;AAED;;;;wBAIwB;AACxB,SAAS,OAAO,CAAC,MAA+B,EAAE,GAAW;IAC3D,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC"}

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

@@ -0,0 +1,57 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schema-anchors.d.ts","sourceRoot":"","sources":["../../src/core/tool-schema-anchors.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;sEACsE;AACtE,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAChE,CAAC;AAEZ;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,GACb;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAAG,IAAI,CA6BzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAC9C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAyBtC;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GAC3C,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAYtC;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAChC,iBAAiB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,IAAI,GACxE,eAAe,CAYjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAClD,GAAG,eAAe,GAAG,IAAI,CAYzB"}

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

@@ -0,0 +1,159 @@
+// 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;
+    }
+    const { tool_call_id: toolCallId, tool_input_schema, tool_output_schema, } = value;
+    if (typeof toolCallId !== "string" || toolCallId === "") {
+        return null;
+    }
+    const schemas = {};
+    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, toolCallId, schemas) {
+    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 = {};
+    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) {
+    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)) {
+            continue;
+        }
+        seeded.set(toolCallId, schemas);
+    }
+    return seeded;
+}
+/** Records each annotated call's toolCallId → registered schemas. */
+export function toolSchemaRecorder(onSchemasAnchored) {
+    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) {
+    if (card.toolInputSchema === null && card.toolOutputSchema === null) {
+        return null;
+    }
+    const schemas = {};
+    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) {
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return undefined;
+    }
+    return schema;
+}
+function _isWellFormedSchemas(schemas) {
+    if (typeof schemas !== "object" || schemas === null) {
+        return false;
+    }
+    const { argsSchema, resultSchema } = schemas;
+    const fieldsAreWellTypedOrAbsent = (argsSchema === undefined || _schemaOf(argsSchema) !== undefined) &&
+        (resultSchema === undefined || _schemaOf(resultSchema) !== undefined);
+    return (fieldsAreWellTypedOrAbsent &&
+        (argsSchema !== undefined || resultSchema !== undefined));
+}
+//# sourceMappingURL=tool-schema-anchors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schema-anchors.js","sourceRoot":"","sources":["../../src/core/tool-schema-anchors.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,28 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-sentence-anchors.d.ts","sourceRoot":"","sources":["../../src/core/tool-sentence-anchors.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAKrD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;wEAEoE;IACpE,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;IAC9C;;;;wCAIoC;IACpC,YAAY,EAAE,CACZ,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,KACb,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;;uBAGmB;IACnB,YAAY,EAAE,CACZ,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KAChC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,iEAAiE;IACjE,UAAU,EAAE,CACV,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,KACvD,eAAe,CAAC;CACtB;AAED,wBAAgB,qBAAqB,CAInC,KAAK,EAAE,OAAO,GAAG,SAAS,EAC1B,OAAO,EAAE;IACP;;yEAEqE;IACrE,WAAW,EAAE,OAAO,CAAC;CACtB,GACA,mBAAmB,CA6CrB"}

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

@@ -0,0 +1,65 @@
+// 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) {
+    function sentenceOf(event) {
+        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();
+            // 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") {
+                    seeded.set(toolCallId, sentence);
+                }
+            }
+            return seeded;
+        },
+        recorderOf: (onAnchored) => {
+            return {
+                onToolCallResultEvent({ event }) {
+                    const sentence = sentenceOf(event);
+                    if (sentence !== null) {
+                        onAnchored(event.toolCallId, sentence);
+                    }
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=tool-sentence-anchors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-sentence-anchors.js","sourceRoot":"","sources":["../../src/core/tool-sentence-anchors.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,kEAAkE;AAClE,oEAAoE;AACpE,yEAAyE;AACzE,yEAAyE;AACzE,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,qEAAqE;AACrE,2EAA2E;AAC3E,wEAAwE;AACxE,uDAAuD;AAIvD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AA+BjE,MAAM,UAAU,qBAAqB;AACnC,sEAAsE;AACtE,uEAAuE;AACvE,iCAAiC;AACjC,KAA0B,EAC1B,OAKC;IAED,SAAS,UAAU,CAAC,KAAc;QAChC,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,KAAK,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC;IACjD,CAAC;IACD,OAAO;QACL,KAAK,EAAE,IAAI,GAAG,EAAE;QAChB,UAAU;QACV,YAAY,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE;YAC/C,IAAI,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC7B,OAAO,QAAQ,CAAC;YAClB,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC/B,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YAC/B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE;YACvB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;YACzC,iEAAiE;YACjE,mEAAmE;YACnE,MAAM,OAAO,GAAG,MAAuC,CAAC;YACxD,KAAK,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,OAAO,EAAE,CAAC;gBAC7C,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBACnE,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,UAAU,EAAE,CAAC,UAAU,EAAE,EAAE;YACzB,OAAO;gBACL,qBAAqB,CAAC,EAAE,KAAK,EAAE;oBAC7B,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;oBACnC,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;wBACtB,UAAU,CAAC,KAAK,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;oBACzC,CAAC;gBACH,CAAC;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,140 @@
+import type { ToolCallState } from "./tool-call-display.js";
+/** The resolved palette a view renders under — "light" | "dark", never the
+ *  authored "auto" (use-resolved-theme-mode.ts resolves it). */
+export type ToolViewThemeMode = "light" | "dark";
+/** A JSON Schema document, verbatim from the wire: the catalog row's
+ *  declared shape, untyped by design — data a view may read, never validated. */
+export type JsonSchema = Record<string, unknown>;
+/** The recorded tool call a view presents — the contract's entire data
+ *  surface. The generics default to today's untyped behaviour so generated
+ *  per-org argument types are usable when they arrive. */
+export interface ToolViewCall<TArgs = Record<string, unknown>, TResult = unknown> {
+    toolName: string;
+    toolCallId: string;
+    status: ToolCallState;
+    /** True while a pending approval or elicitation anchored to this call
+     *  awaits the member. The view may say so; it can never decide. */
+    awaitingDecision: boolean;
+    /** The streamed arguments, parsed, minus the protocol-reserved `caption`
+     *  — the row's label, never an argument. `{}` while the argument text is
+     *  still arriving or is not a JSON record. */
+    args: TArgs;
+    /** The result parsed for presentation: the tool-result/v1 envelope
+     *  unwrapped (core/tool-result-envelope.ts), other JSON passed through.
+     *  Absent until it lands, when not JSON, or when `truncated`. */
+    result?: TResult;
+    /** The result verbatim from the wire; absent until it lands (and
+     *  withheld upstream on errored, denied, cancelled, refused and
+     *  offloaded calls, exactly as the technical panes withhold it). */
+    resultText?: string;
+    /** True when the wire's result was degraded to fit the size cap: the
+     *  bytes in `resultText` are honest; `result` refuses to structure them. */
+    truncated?: boolean;
+    /** True when the wire's result was the context offloader's
+     *  model-facing replacement, not the tool's output. */
+    offloaded?: boolean;
+    errorText?: string;
+    refusalText?: string;
+    /** The tool's registered argument schema, when the wire carried one (the
+     *  `approval_requested` marker or `tool_call_annotated`). Absent
+     *  is a legitimate answer — `undefined`, never `{}`, never inferred — and
+     *  a view must degrade, never demand. The runtime door beside `TArgs`. */
+    argsSchema?: JsonSchema;
+    /** The tool's registered success-result schema (`tool_output_schema`)
+     *  — same channels and absence semantics as `argsSchema`. */
+    resultSchema?: JsonSchema;
+}
+/** What a view receives — the call, and the one ambient fact it may not
+ *  resolve itself. Additively extensible: a future `actions` member is a
+ *  recorded reserved step (tool-views.md), never this contract's. */
+export interface ToolViewProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    call: ToolViewCall<TArgs, TResult>;
+    context: {
+        themeMode: ToolViewThemeMode;
+    };
+}
+/** A mounted view. `update` MUST apply new props in place, so local UI
+ *  state survives the call's status advancing; `destroy` runs on unmount. */
+export interface ToolViewInstance<TArgs = Record<string, unknown>, TResult = unknown> {
+    update(props: ToolViewProps<TArgs, TResult>): void;
+    destroy(): void;
+}
+/** The canonical authoring form: an imperative mount into a package-owned
+ *  container. A throw from `mount` or `update` is the adapter's one failure
+ *  channel — the slot reports it and resolution falls to the rung below.
+ *  `mount`/`update` are METHOD declarations on purpose: bivariant parameters
+ *  let a typed adapter assign into the default-typed registration slot
+ *  (docs/tool-call-contract.md, "Adapter typing" — use `type` aliases). */
+export interface ToolViewAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
+}
+/** The operation-mark role: the identical lifecycle over identical props,
+ *  named apart so the roles can diverge additively (tool-view-slot.tsx). */
+export interface IconAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
+}
+/** One registration, two roles: a view, an icon, or both. `version` is the
+ *  contract version the adapters target; a wire ref resolves only on exact
+ *  match (rungs 1 and 3). Default-typed slots: registries are heterogeneous. */
+export interface ToolViewRegistration {
+    version: number;
+    view?: ToolViewAdapter;
+    icon?: IconAdapter;
+}
+/** The registry a trusted host supplies (`toolViews` on the provider or the
+ *  script-tag elements), keyed by the wire key a backend annotation names
+ *  (rung 1) or the host's exact tool name (rung 2). No code rides the wire. */
+export type ToolViewRegistry = Readonly<Record<string, ToolViewRegistration>>;
+/** True for keys the package owns. A reserved key never resolves through
+ *  the HOST registry — by wire key or tool name — so tool output can never
+ *  name a privileged view and a host cannot occupy the namespace. */
+export declare function isReservedToolViewKey(key: string): boolean;
+/** Rung 3 — the package's own views under reserved `teaflask.*` keys, as
+ *  vanilla adapters (runtime-React-free); the backend names them beside the
+ *  tools in tool_call_display.py. Frozen: nothing registers here at runtime. */
+export declare const PACKAGE_TOOL_VIEWS: ToolViewRegistry;
+/** The tool name a granted catalog action mounts as
+ *  (the serving side's action_tool_name): the slug shown on the
+ *  Actions page, under the `action__` prefix — the one spelling a HOST
+ *  gets. The dashboard's agent-config twin (draft-writers.ts, kept apart
+ *  by the import law) is pinned equal to this and the backend constant by
+ *  the dashboard's action-tool-prefix test. */
+export declare function actionToolName(slug: string): string;
+/** A registry written in action SLUGS — the names the Actions page shows
+ *  — keyed for rung 2 by the tool name each slug mounts as. A registry
+ *  of ordinary tool names composes beside it with a spread. */
+export declare function actionToolViews(bySlug: Readonly<Record<string, ToolViewRegistration>>): ToolViewRegistry;
+/** A statically resolved view candidate: which rung answered, under
+ *  which key, with which adapter. */
+export interface ResolvedToolView {
+    rung: 1 | 2 | 3;
+    key: string;
+    adapter: ToolViewAdapter;
+}
+export interface ResolvedToolViewIcon {
+    rung: 1 | 2 | 3;
+    key: string;
+    adapter: IconAdapter;
+}
+/** The presenter's tool-view slot: the rung 1–3 candidates in ladder order,
+ *  per role, plus the lazily assembled call (tool-call-presentation.ts).
+ *  Rung 4 — the package default — is the definitional terminal, never a
+ *  list member: exhausting `views` IS the resolution "package default". */
+export interface ToolViewResolution {
+    views: readonly ResolvedToolView[];
+    icons: readonly ResolvedToolViewIcon[];
+    call: ToolViewCall;
+}
+/** The four-rung resolution ladder (docs/tool-call-contract.md, "The
+ *  resolution ladder"), static half: host registry by exact `{key,
+ *  version}` (1), host registry by exact tool name (2), package built-ins
+ *  by reserved `teaflask.*` key (3); rung 4 is the definitional default.
+ *  Own-property-guarded lookups; reserved keys refused at both host rungs. */
+export declare function resolvedToolViewsOf(ref: {
+    key: string;
+    version: number;
+} | undefined, toolName: string, registry: ToolViewRegistry | undefined, builtIns?: ToolViewRegistry): {
+    views: readonly ResolvedToolView[];
+    icons: readonly ResolvedToolViewIcon[];
+};
+//# sourceMappingURL=tool-view.d.ts.map

package/dist/core/tool-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-view.d.ts","sourceRoot":"","sources":["../../src/core/tool-view.ts"],"names":[],"mappings":"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"}