@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/use-transcript-folds.js

@@ -4,10 +4,8 @@ import { hostFillDeclines } from "../core/host-fill.js";
 import { currentTurnStartOf, foldedBlocksOf, runFoldsOf, } from "../core/run-folds.js";
 import { subagentOutcomeCountsOf } from "../core/subagent-rows.js";
 import { ElicitationsContext } from "./elicitation-context.js";
-import { resolvedSubagentEntryOf, SubagentDispatchesContext, } from "./subagent-group-row.js";
-/** MessageList's per-render derivations, read in one place: the fold
- *  pass, the hold window, the blocks-mode offsets, the tail receipts and
- *  the trailing-liveness election. */
+import { resolvedSubagentEntryOf } from "../core/subagent-ledger-join.js";
+import { SubagentDispatchesContext, } from "./subagent-group-row.js";
 export function useMessageListDerivations(source, { live, typing, turnOpen, markerBoundaries, turnStartIds, decisionSurfacesInShelf, frameClaimsLiveness, emptyFallback, }) {
     const { cards: elicitationCards } = useContext(ElicitationsContext);
     const { foldedBlocks, flatRows, displayRows } = useTranscriptFolds(source, {
@@ -16,45 +14,14 @@ export function useMessageListDerivations(source, { live, typing, turnOpen, mark
         markerBoundaries,
         turnStartIds,
     });
-    // The current turn's start (the hold window) is the fold pass's own
-    // boundary (core/run-folds.ts): the last user or subagent-delivery row,
-    // or a later DECLARED turn start (agent-mode delivery turns project no
-    // row), so the hold window and the fold window read the same boundaries.
-    // Positional on purpose, never a clock: the optimistic echo is a user
-    // row, so decay fires at send, and a replay renders identically every
-    // time.
     const currentTurnStart = currentTurnStartOf(displayRows, foldedBlocks, turnStartIds);
-    // Blocks mode renders per block, so each row's flat display index —
-    // what the hold window is measured in — is its block's offset plus
-    // its position in the block.
     const blockStarts = _blockStartsOf(foldedBlocks ?? []);
-    // An ANSWERED ask whose call never rendered a row (a wire that named
-    // no tool_call_id, a history whose call never reached the messages)
-    // still renders its Q→A receipt at the tail: the member answered, and
-    // that is content. It is the ONE settled-decision tail render left —
-    // the meta-receipt lines were deleted as a product decision.
     const unrowedAnsweredAsks = decisionSurfacesInShelf
         ? _unrowedAnsweredAsksOf(flatRows, elicitationCards)
         : NO_UNROWED_ASKS;
-    // The liveness anchor is simply the last display row: the only trailing
-    // marker row (turn-failed receipts) trails once the run settled.
     const liveIndex = displayRows.length - 1;
-    // The one trailing-liveness arbiter (a seam, closed at its
-    // mechanism): every element that can claim the beat is decided HERE,
-    // from the same facts its renderer reads, so no host and no tail kind
-    // can double-claim or drop the claim.
     const dispatchesJoin = useContext(SubagentDispatchesContext);
-    // The host's empty surface owns the empty frame: when the host said
-    // "the log is genuinely empty" AND gave the words for it, a package
-    // "Working…" (or the dot) beside those words is a second liveness
-    // claim in one frame — the run viewer's empty streaming state stacked
-    // "No activity yet." over "Working…". The host surface is the claimant
-    // then; the arbiter yields. An empty live log with NO host surface
-    // keeps the standalone headline — one claim either way.
     const hostEmptySurfaceShown = !hostFillDeclines(emptyFallback) && displayRows.length === 0;
-    // One yield rule: the host's empty surface showing, or
-    // the host's declared frame claim, each means the frame already
-    // carries the words — the standalone claimants stand down.
     const livenessClaimant = hostEmptySurfaceShown || frameClaimsLiveness
         ? "none"
         : _trailingLivenessClaimantOf(displayRows, live, typing, dispatchesJoin);
@@ -70,15 +37,8 @@ export function useMessageListDerivations(source, { live, typing, turnOpen, mark
     };
 }
 const NO_UNROWED_ASKS = [];
-/** The fold derivation, pure per render: blocks mode's segmented pass
- *  or rows mode's flat one. All tool calls stay inside their work fold. */
 function useTranscriptFolds(source, { live, turnOpen, markerBoundaries, turnStartIds, }) {
     const { rows, blocks } = source;
-    // Blocks mode: the segmented fold pass, so a host marker
-    // splits folds exactly as a visible row would. Rows mode takes the
-    // branch below it always took — the store surfaces' rendering is
-    // pinned by the pixel suite and the store-composition suites
-    // (the invariant-comment ledger, row 13).
     const foldedBlocks = blocks !== undefined
         ? foldedBlocksOf(blocks, {
             openTailTurn: turnOpen ?? live,
@@ -94,7 +54,6 @@ function useTranscriptFolds(source, { live, turnOpen, markerBoundaries, turnStar
         });
     return { foldedBlocks, flatRows, displayRows };
 }
-/** Each block's offset in the flat display order (blocks mode). */
 function _blockStartsOf(blocks) {
     const starts = [];
     let next = 0;
@@ -104,12 +63,6 @@ function _blockStartsOf(blocks) {
     }
     return starts;
 }
-/** The answered asks with no rendered row to settle on (shelf
- *  composition): a wire that named no tool_call_id, or a history whose
- *  call never reached the messages. Their Q→A receipts render
- *  at the transcript tail — content, never meta-narration. Stale asks
- *  render nothing: the meta-receipt rows were deleted, the quiet
- *  stale line with them. */
 function _unrowedAnsweredAsksOf(rows, elicitationCards) {
     const renderedCallIds = new Set();
     for (const row of rows) {
@@ -120,27 +73,11 @@ function _unrowedAnsweredAsksOf(rows, elicitationCards) {
     return elicitationCards.filter((card) => (card.toolCallId === null || !renderedCallIds.has(card.toolCallId)) &&
         card.status === "answered");
 }
-/** WHO claims the trailing liveness beat — the one arbiter. Exactly one
- *  element may say "work is live" at the transcript tail, across every
- *  host and every tail row kind. Precedence: a claiming tail row (a live
- *  fold, streaming prose, a delegation group with a running member —
- *  resolved through the SAME join the group row renders from); else
- *  `typing` elects the silence-gap dot; else `live` elects the standalone
- *  Working… headline; else none. The full table is in
- *  docs/transcript-surfaces.md and tests/liveness-claimants.test.tsx
- *  executes it. A host-provided empty surface on an empty log outranks
- *  everything here at the call site. The dot OUTRANKS the headline
- *  deliberately: the drill-in preview passes typing alongside live and
- *  keeps its dot; Transcript never passes typing. */
 function _trailingLivenessClaimantOf(displayRows, live, typing, dispatches) {
     const last = displayRows.at(-1);
     const tailClaims = last !== undefined &&
         ((last.kind === "run-fold" && _foldClaimsLiveness(last.members, live)) ||
             (last.kind === "assistant-text" && last.streaming) ||
-            // The group's own headline shimmers exactly when its resolved
-            // counts say a member runs — resolved through the SAME exported
-            // join the group row renders from (never a respelled predicate),
-            // so the arbiter and the row cannot drift.
             (last.kind === "subagent-group" &&
                 subagentOutcomeCountsOf(last.entries.map((entry) => resolvedSubagentEntryOf(entry, dispatches.byOrdinal))).running > 0));
     if (tailClaims) {
@@ -154,13 +91,8 @@ function _trailingLivenessClaimantOf(displayRows, live, typing, dispatches) {
     }
     return "none";
 }
-/** One live spelling of "this fold reads as running" — ActivityRail's
- *  headline and the trailing-liveness arbiter both read it. The trailing
- *  fold's turnLive bridges the quiet beat between one call's result and
- *  the next call's start, so back-to-back calls don't blink the headline. */
 export function _foldClaimsLiveness(members, turnLive) {
     return (turnLive ||
         members.some((row) => (row.kind === "reasoning" && row.streaming) ||
             (row.kind === "tool-call" && row.state === "input-available")));
 }
-//# sourceMappingURL=use-transcript-folds.js.map

package/dist/components/use-transcript.d.ts

@@ -1,41 +1,72 @@
 import type { Message } from "@ag-ui/core";
 import { type AssistantActivitySnapshot } from "../core/activity.js";
-import type { MarkerAnchorsSnapshot } from "../core/connection-epoch.js";
+import type { TranscriptMarkers } from "../core/connection-epoch.js";
 import { type TranscriptRow } from "../core/transcript-rows.js";
 import type { UserTurnMeta } from "../core/user-turn-ledger.js";
-/** The transcript read surface: everything a host needs to render the
- *  assistant's replies, derived exactly the way the package chrome derives it. */
+/**
+ * The transcript as useTranscript returns it: ready-to-render rows, whether the
+ * assistant is working, and the raw inputs the rows were built from.
+ */
 export interface TranscriptSurface {
-    /** transcriptRowsOf(messages, markerAnchors, running, turnMeta) — the
-     *  pure interleave, identity-stable while its four inputs hold. */
+    /**
+     * The conversation as an ordered list of rows, without the message the user
+     * has just sent and that is still on its way.
+     */
     rows: readonly TranscriptRow[];
-    /** `rows` with the composer's optimistic echo appended (withPendingUserEcho).
-     *  Render this; a host that also paints its own bubble would double it. */
+    /**
+     * The rows to render: `rows` plus the user's just-sent message while it is
+     * still being delivered. Don't also draw your own bubble for a sent
+     * message, or it will appear twice.
+     */
     displayRows: readonly TranscriptRow[];
-    /** runReadsAsWorking(activity.newestTurnStatus, decisionsPending) — the
-     *  machine's time. False for the send round trip, so a "working" indicator
-     *  should join the composer contract's pendingSend, as the chrome does. */
+    /**
+     * True while the assistant is working: its turn is queued or running, or
+     * paused with nothing waiting on the user. False while a send is still in
+     * flight, so a working indicator should also check pendingSend from
+     * useConversation().
+     */
     running: boolean;
-    /** The newest turn is non-terminal — broader than `running`: the HITL
-     *  pauses (awaiting_input, parked) count. */
+    /**
+     * True while the newest turn has not finished, including while it is paused
+     * waiting for the user's approval or answer.
+     */
     turnOpen: boolean;
-    /** A member-actionable decision is live — the run is the MEMBER's time. */
+    /**
+     * True while the turn is waiting on the user: an approval or question
+     * awaits their answer, or the server reports one this client has nothing to
+     * show for.
+     */
     decisionsPending: boolean;
-    /** The four raw store reads, as plain values — so transcriptRowsOf(messages,
-     *  markerAnchors, running, turnMeta) type-checks verbatim for a host's own projection. */
+    /**
+     * The raw message list behind the rows (user messages, assistant text,
+     * reasoning, tool calls and tool results). Use it with markerAnchors,
+     * running and turnMeta to call transcriptRowsOf yourself.
+     */
     messages: readonly Message[];
-    markerAnchors: MarkerAnchorsSnapshot;
+    /**
+     * Extra facts the stream reports about messages and tool calls (failures,
+     * timing, schemas, memory saves), already joined into the rows; read it
+     * directly only for custom rendering.
+     */
+    markerAnchors: TranscriptMarkers;
+    /**
+     * The conversation's current run state, such as the newest turn's status
+     * and how many approvals are waiting.
+     */
     activity: AssistantActivitySnapshot;
+    /**
+     * The send time and attachments of each user message, keyed by that
+     * message's id.
+     */
     turnMeta: ReadonlyMap<string, UserTurnMeta>;
 }
 /**
- * The store's read side, projected: the message list and marker anchors
- * folded into the flat row list, plus the run-state facts the rows key on.
- * Mounting registers transcript presence (the lease) — what guarantees the
- * epoch connects and history paints by full replay; unmounting mid-turn changes nothing.
+ * Returns everything needed to render the conversation's transcript yourself,
+ * as rows plus run state. Call it inside TeaflaskAssistantProvider (it throws
+ * otherwise); keep it mounted while the transcript is on screen, because that
+ * is what makes the assistant connect and load an existing conversation's
+ * history.
  */
 export declare function useTranscript(options?: {
-    /** The lease label the store's presence ledger records (the chrome's `surface` prop). */
     surface?: string;
 }): TranscriptSurface;
-//# sourceMappingURL=use-transcript.d.ts.map

package/dist/components/use-transcript.js

@@ -1,27 +1,19 @@
 "use client";
-// The transcript read surface: the ONE derivation from the store's read cells
-// to renderable rows, consumed by components/transcript.tsx and exported public
-// on ./headless — never ./transcript, since the BINDING to a live store rides
-// the provider, which constructs the transport. Chrome-free by construction
-// (tests/bundle-closure.test.ts): VALUE-imports only core/*, React, ./headless
-// seams.
 import { useEffect, useMemo } from "react";
 import { isTerminalTurnStatus, } from "../core/activity.js";
 import { runReadsAsWorking } from "../core/run-status.js";
+import { withDispatchLedger } from "../core/subagent-ledger-join.js";
 import { approvalAwaitsMember, elicitationAwaitsMember, } from "../core/suspension-queue.js";
 import { transcriptRowsOf, withPendingUserEcho, } from "../core/transcript-rows.js";
 import { useConversation } from "./conversation-context.js";
 import { useAssistantSession } from "./teaflask-assistant-provider.js";
 import { useCell } from "./use-store-cell.js";
-/**
- * The store's read side, projected: the message list and marker anchors
- * folded into the flat row list, plus the run-state facts the rows key on.
- * Mounting registers transcript presence (the lease) — what guarantees the
- * epoch connects and history paints by full replay; unmounting mid-turn changes nothing.
- */
+import { useThreadDispatches } from "./use-thread-dispatches.js";
 export function useTranscript(options) {
-    const { store } = useAssistantSession();
+    const { session, store } = useAssistantSession();
     const { pendingEcho } = useConversation();
+    const connection = useCell(store.connection);
+    const dispatches = useThreadDispatches(session, connection?.threadId ?? null);
     const messages = useCell(store.messages);
     const markerAnchors = useCell(store.markerAnchors);
     const approvalCards = useCell(store.approvals);
@@ -30,26 +22,14 @@ export function useTranscript(options) {
     const turnMeta = useCell(store.turnMeta);
     const surface = options?.surface ?? "headless";
     useEffect(() => store.acquireTranscriptLease(surface), [store, surface]);
-    // The decision-live fact: the one honest signal that the run is the
-    // MEMBER's time — claimed only while a decision surface exists, via the
-    // shared predicates, never the sorted queue (whose row-index input
-    // changes every token). The gap counts too: the role="alert" banner says
-    // the run waits. Truthiness on purpose: a partial snapshot's undefined
-    // is no-gap.
     const decisionSurfaceLive = useMemo(() => approvalCards.some(approvalAwaitsMember) ||
         elicitationCards.some(elicitationAwaitsMember), [approvalCards, elicitationCards]);
     const decisionsPending = decisionSurfaceLive || Boolean(activity.pendingDecisionGap);
-    // "The run is live" is the machine's time: queued/working, or a
-    // non-terminal pause with no live decision surface — the same function the
-    // sr-only announcer speaks, so headline and live region never disagree. It
-    // narrows the tool rows' no-result presentation and the newest rows' streaming flag.
     const running = runReadsAsWorking(activity.newestTurnStatus, decisionsPending);
-    // "The turn is open" is broader than "the run is live": it includes the HITL
-    // pauses. The completed-episode fold keys on terminality, so a pause never
-    // unifies the tail turn mid-flight and pops it back out on resume.
     const turnOpen = activity.newestTurnStatus !== null &&
         !isTerminalTurnStatus(activity.newestTurnStatus);
-    const rows = useMemo(() => transcriptRowsOf(messages, markerAnchors, running, turnMeta), [messages, markerAnchors, running, turnMeta]);
+    const wireRows = useMemo(() => transcriptRowsOf(messages, markerAnchors, running, turnMeta), [messages, markerAnchors, running, turnMeta]);
+    const rows = useMemo(() => withDispatchLedger(wireRows, dispatches), [wireRows, dispatches]);
     const displayRows = useMemo(() => withPendingUserEcho(rows, pendingEcho), [pendingEcho, rows]);
     return {
         rows,
@@ -63,4 +43,3 @@ export function useTranscript(options) {
         turnMeta,
     };
 }
-//# sourceMappingURL=use-transcript.js.map

package/dist/components/user-message.js

@@ -1,19 +1,5 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-// The adopted register — bake-off 2026-07-30 (assistant-ui thread.tsx's user message): a muted
-// rounded-xl bubble right-anchored behind a wide reserved gutter, so
-// long messages never crowd the left edge. assistant-ui's markup with
-// the action bar and branch picker removed (the widget has neither).
-// Attachments stack above the bubble, right-anchored with it; an
-// attachment-only message is just the stack, no empty bubble.
-//
-// Beneath the bubble, one reserved meta row: the turn's timestamp and
-// the package's one copy affordance are both hover/focus-revealed (the
-// roster chevron's reveal idiom; always visible on coarse pointers).
-// The row's height is reserved whether or not the button shows, so the
-// reveal never shifts the message. An attachment-only message renders
-// no meta row: there is no text to copy, and its turn's stamp has no
-// bubble to belong to.
 import { conversationalTimeOf } from "../core/time-labels.js";
 import { AttachmentChips } from "./attachment-chips.js";
 import { CopyTextButton } from "./copy-text-button.js";
@@ -21,4 +7,3 @@ export function UserMessage({ children, attachments = [], createdAt, }) {
     const time = createdAt !== undefined ? conversationalTimeOf(createdAt) : null;
     return (_jsxs("div", { className: "tf:group/user-message tf:flex tf:flex-col tf:items-end tf:gap-2 tf:ps-20", "data-role": "user", children: [_jsx(AttachmentChips, { attachments: attachments }), children !== "" ? (_jsxs(_Fragment, { children: [_jsx("div", { className: "tf:min-w-0 tf:rounded-xl tf:bg-tf-muted tf:px-4 tf:py-2 tf:text-tf-body tf:break-words tf:whitespace-pre-wrap tf:text-tf-foreground", children: children }), _jsxs("div", { className: "tf:flex tf:h-7 tf:items-center tf:justify-end tf:gap-1", children: [time !== null ? (_jsx("time", { dateTime: createdAt, title: time.full, className: "tf:text-xs tf:text-tf-muted-foreground tf:opacity-0 tf:transition-opacity tf:group-hover/user-message:opacity-100 tf:group-focus-within/user-message:opacity-100 tf:pointer-coarse:opacity-100", children: time.label })) : null, _jsx(CopyTextButton, { text: children, label: "Copy message", className: "tf:opacity-0 tf:transition-opacity tf:group-hover/user-message:opacity-100 tf:group-focus-within/user-message:opacity-100 tf:focus-visible:opacity-100 tf:pointer-coarse:opacity-100" })] })] })) : null] }));
 }
-//# sourceMappingURL=user-message.js.map

package/dist/contract/actions-adapter.d.ts

@@ -1,53 +1,104 @@
-/** The catalog identity of the action being executed — server-built, never model prose. */
+/** The catalog entry an action request comes from. */
 export interface ActionIntentAction {
+    /**
+     * The action's identifier in your catalog; the agent calls it as the tool
+     * action__<slug>.
+     */
     slug: string;
+    /** The action's human-readable title from your catalog. */
     title: string;
 }
 /**
- * One action the assistant asks this page to perform: the server-built
- * request — method, path template, validated arguments — from the org's
- * vetted actions catalog. `pathTemplate` is app-relative
- * ("/subscriptions/{subscription_id}"); the origin is always the
- * adapter's own.
+ * One action request the assistant asks your page to perform, built by Teaflask
+ * from your actions catalog with arguments already validated against the
+ * action's schemas. Your actions adapter receives it.
  */
 export interface ActionIntent {
+    /** Which catalog action this request is for. */
     action: ActionIntentAction;
+    /**
+     * The HTTP method, in upper case - GET, HEAD, POST, PUT, PATCH or DELETE.
+     */
     method: string;
+    /**
+     * The path relative to your API, with {name} placeholders, for example
+     * "/subscriptions/{subscription_id}". It never includes an origin, so the
+     * request always goes where your adapter sends it.
+     */
     pathTemplate: string;
+    /**
+     * Values for the placeholders in pathTemplate, keyed by name. The cookies
+     * and headers adapters substitute them URL-encoded.
+     */
     pathParams: Record<string, unknown>;
+    /**
+     * Query-string parameters, keyed by name; empty when there are none. The
+     * cookies and headers adapters drop null or undefined values and
+     * JSON-encode non-scalar ones.
+     */
     query: Record<string, unknown>;
-    /** The JSON request body; absent when the action sends none. */
+    /**
+     * The JSON request body; absent when the action sends none. The cookies and
+     * headers adapters send it with Content-Type application/json.
+     */
     body?: unknown;
 }
 /**
- * Session-cookie APIs: the package assembles the URL under `baseUrl` and
- * fetches with credentials included — the request runs in the user's own
- * session, so the assistant can do nothing the user couldn't.
+ * For APIs authenticated by session cookies. The package fetches baseUrl plus
+ * the action's path with credentials included, so each request runs in the
+ * user's own session; an API on another origin must allow credentialed CORS
+ * from your page.
  */
 export interface CookiesActionsAdapter {
+    /** Selects the cookies adapter. */
     kind: "cookies";
+    /**
+     * The URL your action paths are appended to, such as
+     * "https://app.example.com/api"; a trailing slash is ignored.
+     */
     baseUrl: string;
 }
 /**
- * Token-auth APIs: the package assembles the URL under `baseUrl` and
- * asks `getHeaders` per action (may be async — mint or refresh inside).
+ * For APIs authenticated by a token or other headers. The package builds the
+ * URL the same way as the cookies adapter and adds the headers getHeaders
+ * returns.
  */
 export interface HeadersActionsAdapter {
+    /** Selects the headers adapter. */
     kind: "headers";
+    /**
+     * The URL your action paths are appended to, such as
+     * "https://api.example.com/v1"; a trailing slash is ignored.
+     */
     baseUrl: string;
+    /**
+     * Called before every action request with that request; return the headers
+     * to send, such as Authorization. It may be async to fetch or refresh a
+     * token, its headers override the package's Content-Type, and throwing
+     * reports the action as failed.
+     */
     getHeaders: (intent: ActionIntent) => Record<string, string> | Promise<Record<string, string>>;
 }
 /**
- * Full control: the host's own request wrapper receives the whole intent
- * and resolves with the API's response body. A resolved promise reads as
- * a success; a rejection reads as a failed execution and is reported to
- * the assistant as such — the convention every wrapper in this class
- * (an orval mutator, an axios instance) already follows by throwing on
- * non-2xx.
+ * Full control - you perform the HTTP request yourself, for example through
+ * your existing API client.
  */
 export interface RequestActionsAdapter {
+    /** Selects the request adapter. */
     kind: "request";
+    /**
+     * Performs the request and resolves with your API's response body, which
+     * the agent receives with status 200. Reject (for example by throwing on a
+     * non-2xx response) to report the action as failed.
+     */
     execute: (intent: ActionIntent) => Promise<unknown>;
 }
+/**
+ * How the assistant calls your API as the signed-in user, passed as the
+ * provider's actionsAdapter prop; without one the assistant cannot perform
+ * actions and tells the user to do them. The response's status and body (parsed
+ * as JSON, otherwise text) go back to the agent; a non-2xx status counts as
+ * your API's answer, not a failure, and bodies over about 16,000 characters are
+ * truncated.
+ */
 export type ActionsAdapter = CookiesActionsAdapter | HeadersActionsAdapter | RequestActionsAdapter;
-//# sourceMappingURL=actions-adapter.d.ts.map

package/dist/contract/assistant-config.d.ts

@@ -1,2 +1 @@
 export type { AssistantConfigResponse, AttachmentPolicyResponse as ServedAttachmentPolicy, ModelChoiceResponse as ServedModelChoice, RouteSuggestions as ServedRouteSuggestions, SuggestionsConfig as ServedSuggestionsConfig, ThinkingEffort as ServedThinkingEffort, } from "../generated/models/index.js";
-//# sourceMappingURL=assistant-config.d.ts.map

package/dist/contract/dispatches.js

@@ -1,20 +1,4 @@
-// The thread's subagent dispatch ledger: the serving projection
-// is receipts/status/summary — no row id, no model; summary is
-// the child report's bounded excerpt stamped at settle — and the
-// package's public names for it stay stable over the generated ones.
-// Rows join the
-// transcript's dispatch receipts by ORDINAL — the ask's identity;
-// child_session_id is the drill-in handle, and a resume
-// chain shares it across rows — and the row's status outranks the
-// receipt's frozen outcome (the serving contract, "Reading a thread's
-// subagent dispatches").
 import { AgentDispatchStatus } from "../generated/models/index.js";
-// The predicates take the generated union, never bare string — a renamed
-// status word in the spec must fail the compile here, not silently turn
-// every ledger row into finished-and-not-failed (the dashboard's
-// dispatch-status twin takes the same posture).
-// Running means the child still owns its row: dispatched, or paused for
-// an answer it cannot give itself — both are open, unsettled.
 export function dispatchIsRunning(dispatch) {
     return (dispatch.status === AgentDispatchStatus.dispatched ||
         dispatch.status === AgentDispatchStatus.paused);
@@ -22,25 +6,9 @@ export function dispatchIsRunning(dispatch) {
 export function dispatchFailed(dispatch) {
     return dispatch.status === AgentDispatchStatus.failed;
 }
-/** Paused for an answer only the member's browser can give — a running
- *  row whose request the transcript can name. */
 export function dispatchIsPaused(dispatch) {
     return dispatch.status === AgentDispatchStatus.paused;
 }
-/** Whether the ledger AFFIRMATIVELY says this child is done — a row we
- *  hold whose status is succeeded or failed. The one predicate a
- *  stream-end verdict may read "settled" from: its
- *  complement is not "running" but "not known to have settled", which
- *  covers a still-dispatched row AND no row at all — a ledger read that
- *  bounded out or failed with no prior snapshot. A ledger not read is not
- *  a ledger that settled (the backend's own null posture on the
- *  sse_stream_teardown line), so undefined answers false here, and a
- *  judge asking "did it settle?" through this predicate can never turn an
- *  unreadable ledger into Finished. Enumerated over every state:
- *
- *    dispatched → false     succeeded → true
- *    paused     → false     failed    → true
- *    undefined (unread) → false */
 export function dispatchHasSettled(dispatch) {
     if (dispatch === undefined) {
         return false;
@@ -54,4 +22,3 @@ export function dispatchHasSettled(dispatch) {
             return false;
     }
 }
-//# sourceMappingURL=dispatches.js.map

package/dist/contract/errors.d.ts

@@ -1,7 +1,12 @@
 export type { ServingErrorCode } from "../generated/models/index.js";
 import type { ServingErrorCode } from "../generated/models/index.js";
+/**
+ * An error code: one of the known ServingErrorCode values, or any other string,
+ * since new codes may be added. Handle unknown codes by showing the error's
+ * message.
+ */
 export type ServingErrorCodeOnTheWire = ServingErrorCode | (string & {});
-export interface ServingErrorBody {
+interface ServingErrorBody {
     code: ServingErrorCodeOnTheWire;
     message: string;
     details?: unknown;
@@ -9,4 +14,3 @@ export interface ServingErrorBody {
 export interface ServingErrorEnvelope {
     error: ServingErrorBody;
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/contract/events.d.ts

@@ -1,7 +1,5 @@
-import type { ApprovalRequestedMarker, ApprovalResolvedMarker, InterruptAnswerConsumedMarker, RunResumedMarker, SubagentResultsDeliveredMarker, ToolExecutionRequestedMarker } from "../generated/models/index.js";
-export type AssistantStreamEventType = "TEXT_MESSAGE_START" | "TEXT_MESSAGE_CONTENT" | "TEXT_MESSAGE_END" | "REASONING_START" | "REASONING_END" | "REASONING_MESSAGE_START" | "REASONING_MESSAGE_CONTENT" | "REASONING_MESSAGE_END" | "TOOL_CALL_START" | "TOOL_CALL_ARGS" | "TOOL_CALL_END" | "TOOL_CALL_RESULT" | "RUN_STARTED" | "RUN_FINISHED" | "RUN_ERROR" | "CUSTOM";
+import type { ApprovalRequestedMarker, ApprovalResolvedMarker, InterruptAnswerConsumedMarker, SubagentResultsDeliveredMarker, ToolExecutionRequestedMarker } from "../generated/models/index.js";
 export declare const RUN_RESUMED_EVENT_NAME: "run_resumed";
-export type RunResumedPayload = RunResumedMarker;
 export declare const APPROVAL_REQUESTED_EVENT_NAME: "approval_requested";
 export type ApprovalRequestedPayload = ApprovalRequestedMarker & Required<Pick<ApprovalRequestedMarker, "tool_args" | "tool_input_schema" | "tool_output_schema" | "round" | "gated" | "trust_available">>;
 export declare const APPROVAL_RESOLVED_EVENT_NAME: "approval_resolved";
@@ -18,4 +16,3 @@ export declare const SUBAGENT_RESULTS_DELIVERED_EVENT_NAME: "subagent_results_de
 export type SubagentResultsDeliveredPayload = SubagentResultsDeliveredMarker;
 export declare const TURN_USAGE_RECORDED_EVENT_NAME: "turn_usage_recorded";
 export declare const MEMORY_UPDATED_EVENT_NAME: "memory_updated";
-//# sourceMappingURL=events.d.ts.map

package/dist/contract/events.js

@@ -1,43 +1,13 @@
-// The stream's frozen AG-UI event vocabulary. Structural shapes come from
-// @ag-ui/core; CUSTOM marker names and payloads are generated from
-// serving-openapi.json. Clients MUST ignore unrecognized events and fields.
 import { AssistantStreamMarkerName } from "../generated/models/index.js";
-// A retried activity attempt, emitted only when attempt > 1 — never a
-// message; the client reads it for retry severance only (stream-resume).
 export const RUN_RESUMED_EVENT_NAME = AssistantStreamMarkerName.run_resumed;
-// One per pending approval while the turn awaits input; tool_call_id anchors
-// the ask to the already-streamed tool call (the card is keyed by interrupt_id).
 export const APPROVAL_REQUESTED_EVENT_NAME = AssistantStreamMarkerName.approval_requested;
-// The durable receipt of a human's answer to an approval_requested ask —
-// never a message; a replayed receipt flips the replayed card to answered.
 export const APPROVAL_RESOLVED_EVENT_NAME = AssistantStreamMarkerName.approval_resolved;
-// A resume carried this pause's answer into the agent: never
-// rendered, it is consumed evidence for the pending-decision-gap derivation.
 export const INTERRUPT_ANSWER_CONSUMED_EVENT_NAME = AssistantStreamMarkerName.interrupt_answer_consumed;
-// The turn settled failed outside any single tool — never a
-// message or banner. Its live run ends in RUN_ERROR; on replay the terminal
-// demotes to RUN_FINISHED and this marker is the failure's durable record.
 export const TURN_FAILED_EVENT_NAME = AssistantStreamMarkerName.turn_failed;
-// The member ended the turn; same { receipt } shape as turn_failed.
 export const TURN_STOPPED_EVENT_NAME = AssistantStreamMarkerName.turn_stopped;
-// One per pending client-executed tool call while the turn awaits input —
-// this package's execution loop executes it and POSTs the result back.
 export const TOOL_EXECUTION_REQUESTED_EVENT_NAME = AssistantStreamMarkerName.tool_execution_requested;
-// Durable receipt of a delivered result: a reconnect never re-runs the request.
 export const TOOL_RESULT_RECORDED_EVENT_NAME = AssistantStreamMarkerName.tool_result_recorded;
-// Backend-authored human copy for one tool call, anchored by tool_call_id. May
-// arrive more than once per call: merged per field by tool-call-display-anchors.ts.
 export const TOOL_CALL_ANNOTATED_EVENT_NAME = AssistantStreamMarkerName.tool_call_annotated;
-// A machine-started delivery turn opens its run with this receipt
-// naming the settled dispatches it pushes. A quiet divider, never a message.
 export const SUBAGENT_RESULTS_DELIVERED_EVENT_NAME = AssistantStreamMarkerName.subagent_results_delivered;
-// The turn's settled token totals: one per settled turn that had
-// usage to sum, landed just before the terminal. Only finality "final" is
-// settled truth ("partial" sums are lower bounds); absence means UNKNOWN —
-// never an estimate or zero.
 export const TURN_USAGE_RECORDED_EVENT_NAME = AssistantStreamMarkerName.turn_usage_recorded;
-// One agent-memory row actually written during the run; a dedup
-// no-op emits nothing. memory_id reconciles re-deliveries. End-user safe:
-// a scope token and a canned sentence, never the memory's content.
 export const MEMORY_UPDATED_EVENT_NAME = AssistantStreamMarkerName.memory_updated;
-//# sourceMappingURL=events.js.map

package/dist/contract/identity.d.ts

@@ -1,2 +1 @@
-export type { CurrentVisitorResponse as WhoamiResponse, EndUserIdentity, MintVisitorTokenRequest, MintVisitorTokenResponse, PublishableKeyMode, VisitorTier, } from "../generated/models/index.js";
-//# sourceMappingURL=identity.d.ts.map
+export type { MintVisitorTokenRequest, MintVisitorTokenResponse, VisitorTier, } from "../generated/models/index.js";

package/dist/contract/subscriptions.d.ts

@@ -1,2 +1,16 @@
-export type { CreateDeviceAuthorizationResponse as SubscriptionDeviceAuthorization, PollDeviceAuthorizationResponse as SubscriptionDeviceAuthorizationPoll, ServingSubscriptionStatus as SubscriptionStatus, SubscriptionCredentialState, SubscriptionProvider, } from "../generated/models/index.js";
-//# sourceMappingURL=subscriptions.d.ts.map
+import type { SubscriptionProvider } from "../generated/models/index.js";
+export type { BeginSubscriptionAuthorizationResponse as SubscriptionAuthorization, CompleteSubscriptionAuthorizationRequest as SubscriptionAuthorizationCompletionRequest, CompleteSubscriptionAuthorizationResponse as SubscriptionAuthorizationCompletion, ServingSubscriptionStatus as SubscriptionStatus, SubscriptionProvider, } from "../generated/models/index.js";
+declare const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+export type SubscriptionConnectMessage = {
+    type: typeof SUBSCRIPTION_CONNECT_MESSAGE_TYPE;
+    provider: SubscriptionProvider;
+    kind: "code";
+    code: string;
+    state: string;
+    client_id: string | null;
+} | {
+    type: typeof SUBSCRIPTION_CONNECT_MESSAGE_TYPE;
+    provider: SubscriptionProvider;
+    kind: "denied" | "failed";
+};
+export declare function subscriptionConnectMessageOf(event: MessageEvent, serverOrigin: string, provider: SubscriptionProvider): SubscriptionConnectMessage | null;