@teaflask/assistant 0.3.0 → 0.7.0

package/dist/core/tool-call-presentation.d.ts

@@ -1,39 +1,48 @@
 import type { ToolCallState, ToolCallViewModel } from "./tool-call-display.js";
 import type { ToolViewRegistry, ToolViewResolution } from "./tool-view.js";
-/** The semantic icon vocabulary — operational meaning, never a brand or
- *  a tool name. Open on the wire; unknown values resolve to "generic". */
+/**
+ * Every icon kind a tool call row can show: search, file, terminal (running a
+ * command), question (asking the user), memory, delegation (sub-agents),
+ * routine (finding or preparing actions), todo, navigation (opening, reading or
+ * filling in your page) and generic.
+ */
 export declare const TOOL_CALL_ICONS: readonly ["search", "file", "terminal", "question", "memory", "delegation", "routine", "todo", "navigation", "generic"];
+/** One icon kind from TOOL_CALL_ICONS. */
 export type ToolCallIcon = (typeof TOOL_CALL_ICONS)[number];
 /**
- * One tool call's resolved presentation — every consumer's single source.
- * Slots, and who reads them: the transcript row takes headline, icon and
- * status; resolved-action and provenance summaries take settledSummary;
- * subagent presence takes currentWorkLabel; toolView is the resolution
- * ladder's answer (tool-views.md) and the row's whole body — no raw
- * payload disclosure exists. The approval banner reads no slot.
+ * Everything needed to render one tool call row, as returned by
+ * toolCallPresentationOf.
  */
 export interface ToolCallPresentation {
-    /** The transcript row's words — the fallback ladder's answer:
-     *  backend copy when the wire sent it, the mechanical
-     *  protocol-state frame otherwise. */
+    /**
+     * The row's label. It is the agent's caption or the server's text when
+     * there is one, else wording built from the tool name and state, such as
+     * "Running create ticket…" or "create ticket failed".
+     */
     headline: string;
+    /**
+     * The icon kind to show; "generic" when the server named none or one this
+     * version doesn't know.
+     */
     icon: ToolCallIcon;
+    /** The call's state. */
     status: ToolCallState;
-    /** The line a settled call leaves behind — BY DEFINITION the resolved
-     *  headline (the ladder's settled arms are the summary: completion
-     *  copy, error copy or the failed frame, the refusal frame, the
-     *  not-approved frame). The slot is named separately so summary
-     *  consumers bind here, not to the row's wording; if the two are ever
-     *  meant to differ, the divergence lands in this one resolver, never
-     *  in a consumer. */
-    settledSummary: string;
-    /** The present-progressive "what it is doing now" line — the
-     *  ladder's RUNNING arm regardless of the view's own state, so
-     *  consumers need no state guard of their own. */
+    /**
+     * The call's running-state label, whatever its actual state. Used for a
+     * sub-agent's line saying what it is doing now.
+     */
     currentWorkLabel: string;
+    /**
+     * The tool views and icons that match the call, and the call they receive.
+     */
     toolView: ToolViewResolution;
 }
+/**
+ * Works out everything needed to render one tool call row: its label, icon,
+ * state, its running-state label and matching tool view. Pass your `toolViews`
+ * registry, and `awaitingDecision: true` while an approval or question tied to
+ * the call is waiting on the user.
+ */
 export declare function toolCallPresentationOf(view: ToolCallViewModel, registry?: ToolViewRegistry, options?: {
     awaitingDecision?: boolean;
 }): ToolCallPresentation;
-//# sourceMappingURL=tool-call-presentation.d.ts.map

package/dist/core/tool-call-presentation.js

@@ -1,16 +1,7 @@
-// One presenter, many consumers: the transcript row, the
-// resolved-action summary, the subagent current-work label and the
-// tool-view slot all read ONE resolved presentation — consumers select
-// slots, none reinterprets the raw display envelope (that would fork the
-// fallback ladder). Unknown wire vocabulary collapses to the documented
-// fallbacks here and only here, so a stored display survives a vocabulary
-// the build predates. React-free by design.
 import { toolRowHeadlineOf } from "./tool-call-display.js";
 import { toolResultEnvelopePayloadOf } from "./tool-result-envelope.js";
 import { STEP_CAPTION_ARG_KEY, withoutStepCaption } from "./step-caption.js";
 import { resolvedToolViewsOf } from "./tool-view.js";
-/** The semantic icon vocabulary — operational meaning, never a brand or
- *  a tool name. Open on the wire; unknown values resolve to "generic". */
 export const TOOL_CALL_ICONS = [
     "search",
     "file",
@@ -26,20 +17,12 @@ export const TOOL_CALL_ICONS = [
 export function toolCallPresentationOf(view, registry, options) {
     const headline = toolRowHeadlineOf(view);
     const resolved = resolvedToolViewsOf(view.display?.view, view.toolName, registry);
-    // The call is assembled LAZILY, memoized per presentation, and its
-    // RESULT structures lazier still (see _toolViewCallOf): the row's slot
-    // reads the call on every render, the default view reads args alone,
-    // and a transcript re-renders every row per streamed token — so a
-    // rung-4 row never structures its result, and the parse memo holds
-    // only what a mounted view read. The getters keep the single-
-    // resolution-point law: assembly still happens only here, on first read.
     let call;
     const awaitingDecision = options?.awaitingDecision === true;
     return {
         headline,
         icon: _iconOf(view.display?.icon),
         status: view.state,
-        settledSummary: headline,
         currentWorkLabel: toolRowHeadlineOf({ ...view, state: "input-available" }),
         toolView: {
             views: resolved.views,
@@ -58,20 +41,6 @@ function _iconOf(token) {
     }
     return "generic";
 }
-/**
- * The tool-view call, assembled once here: parsing wire text into
- * renderable data is resolution, and it must not fork per consumer.
- * `context.themeMode` is deliberately NOT assembled here — it is the
- * slot's ambient fact (use-resolved-theme-mode.ts), not replay data.
- * `result` and `truncated` are lazy accessors over the verbatim
- * resultText: a settled result can run to the door's 20k and most rows
- * (rung 4, whose default view reads args alone) never look at it, so
- * the structuring parse happens on first read and once per call.
- * IDENTITY LAW: every value on the call is identity-stable across a
- * re-render with unchanged source, because the mount slot's structural
- * delivery guard rests on it. The member-by-member census:
- * docs/tool-call-contract.md, "The identity law".
- */
 function _toolViewCallOf(view, awaitingDecision) {
     const call = {
         toolName: view.toolName,
@@ -107,8 +76,6 @@ function _toolViewCallOf(view, awaitingDecision) {
     if (view.refusalText !== undefined) {
         call.refusalText = view.refusalText;
     }
-    // Absent stays absent: a tool with no declared schema hands
-    // the view `undefined`, never `{}` and never an invented one.
     if (view.argsSchema !== undefined) {
         call.argsSchema = view.argsSchema;
     }
@@ -117,11 +84,6 @@ function _toolViewCallOf(view, awaitingDecision) {
     }
     return call;
 }
-/** The tool-result/v1 envelope unwrap (core/tool-result-envelope.ts): a
- *  {payload} box structures, null refuses — the wire's bytes were
- *  degraded to fit the size cap, and a complete-looking `result` over a
- *  cut payload would be a wrong claim; the honest flag rides instead,
- *  beside the verbatim resultText. Non-JSON output structures nothing. */
 function _structuredResultOf(output) {
     const parsed = _jsonDocumentOf(output);
     if (parsed === undefined) {
@@ -130,11 +92,7 @@ function _structuredResultOf(output) {
     const box = toolResultEnvelopePayloadOf(parsed.document);
     return box === null ? { truncated: true } : { result: box.payload };
 }
-/** The one shared empty-args identity (see the identity law above). */
 const EMPTY_ARGS = Object.freeze({});
-/** The streamed arguments, parsed whole: a JSON record when complete,
- *  EMPTY_ARGS while the tail is still arriving or when the text is not
- *  a record — a view must never see half an argument object. */
 function _argsOf(argsText) {
     const parsed = _jsonDocumentOf(argsText);
     if (parsed === undefined || !_isRecord(parsed.document)) {
@@ -145,9 +103,6 @@ function _argsOf(argsText) {
     }
     return _captionlessArgsOf(parsed.document);
 }
-// The reserved-key strip keeps the identity law: keyed on the memoized
-// document, one caption-less copy per source text, the shared document
-// itself never mutated.
 const _captionlessArgs = new WeakMap();
 function _captionlessArgsOf(document) {
     const memoized = _captionlessArgs.get(document);
@@ -159,15 +114,8 @@ function _captionlessArgsOf(document) {
     _captionlessArgs.set(document, args);
     return args;
 }
-// The parse memo: identity by construction, keyed on the source text, so
-// "same source text" and "same object" are one fact. The memoized document
-// is SHARED across readers (never mutate what a call hands you); failures
-// are not memoized; the cap is a wholesale reset, not an LRU
-// (docs/tool-call-contract.md, "The parse memo").
 const JSON_MEMO_MAX_ENTRIES = 512;
 const _jsonMemo = new Map();
-/** JSON.parse behind a box, so a legitimately-null document stays
- *  distinguishable from "not JSON". */
 function _jsonDocumentOf(text) {
     const memoized = _jsonMemo.get(text);
     if (memoized !== undefined) {
@@ -188,4 +136,3 @@ function _jsonDocumentOf(text) {
 function _isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=tool-call-presentation.js.map

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

@@ -1,8 +1,3 @@
-// The tool-cancel anchor set: a cancelled TOOL_CALL_RESULT's content is
-// the model-facing cancellation text, so the transcript reads this set to
-// light the call's cancelled state and keep that text off the Result
-// pane. 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("cancelled");
 export const EMPTY_TOOL_CANCEL_ANCHORS = anchors.empty;
@@ -10,4 +5,3 @@ export const toolCallCancelledOf = anchors.flagOf;
 export const withToolCancelAnchored = anchors.withAnchored;
 export const wellFormedToolCancelAnchorsOf = anchors.wellFormedOf;
 export const toolCancelRecorder = anchors.recorderOf;
-//# sourceMappingURL=tool-cancel-anchors.js.map

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

@@ -1,22 +1,6 @@
-// The tool-decision anchor set: the durable record that a call
-// carried a member decision, keyed by tool_call_id. The placement hold
-// reads THIS, never the pruned live card stores — the hold window is the
-// TURN. A pure fold over replayed CUSTOM markers: docs/decision-anchors.md.
 import { APPROVAL_REQUESTED_EVENT_NAME, TOOL_EXECUTION_REQUESTED_EVENT_NAME, } from "../contract/events.js";
-// The kinds leaf, never execution-handlers: this module is a value
-// export of the ./transcript projection entry, and the handlers module
-// drags the transport/reader/affordance layers that entry's law bans
-// (tests/bundle-closure.test.ts pins it).
 import { MEMBER_ANSWERABLE_KINDS } from "./execution-kinds.js";
 export const EMPTY_TOOL_DECISION_ANCHORS = new Set();
-/**
- * Narrow a CUSTOM event to the tool call id it marks as decision-bearing,
- * or null: an approval_requested with a tool_call_id, or a
- * tool_execution_requested whose request.kind is member-answerable. Anything malformed is ignored — the contract's
- * "clients MUST ignore events and fields they do not recognize". An
- * unanchored ask (tool_call_id null — a wire that named no call) marks
- * nothing: there is no row to hold open.
- */
 export function toolDecisionAnchorOf(name, value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -37,21 +21,12 @@ export function toolDecisionAnchorOf(name, value) {
             return null;
         }
         const kind = request.kind;
-        // MEMBER_ANSWERABLE_KINDS, not the single ask kind: the anchor marks
-        // "a member decision rode this call", and a future member-answerable
-        // kind must hold its row without a second edit here.
         return typeof kind === "string" && MEMBER_ANSWERABLE_KINDS.has(kind)
             ? toolCallId
             : null;
     }
     return null;
 }
-/**
- * Idempotent anchor merge: 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 returns
- * the set unchanged — identity is the publish gate.
- */
 export function withToolDecisionAnchored(previous, toolCallId) {
     if (previous.has(toolCallId)) {
         return previous;
@@ -60,11 +35,6 @@ export function withToolDecisionAnchored(previous, toolCallId) {
     next.add(toolCallId);
     return next;
 }
-/**
- * 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 wellFormedToolDecisionAnchorsOf(stored) {
     const seeded = new Set();
     for (const toolCallId of stored) {
@@ -84,4 +54,3 @@ export function toolDecisionRecorder(onDecisionAnchored) {
         },
     };
 }
-//# sourceMappingURL=tool-decision-anchors.js.map

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.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.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.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.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.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.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,24 @@
 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. */
+/**
+ * The JSON Schemas a tool declared. Either field is absent when that schema was
+ * not declared.
+ */
 export interface ToolCallSchemas {
+    /** The JSON Schema of the tool's arguments. */
     argsSchema?: JsonSchema;
+    /** The JSON Schema of the tool's successful result. */
     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