@teaflask/assistant 0.6.0 → 0.7.1

package/dist/components/use-thread-dispatches.js

@@ -1,374 +1,16 @@
 "use client";
 import { useCallback, useEffect, useMemo } from "react";
-import { dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
-import { ObservableCell } from "../core/observable-cell.js";
-import { dispatchReceiptOf } from "../core/subagent-rows.js";
-import { listThreadDispatches } from "../transport/serving-api.js";
-import { resolvedSubagentEntryOf } from "./subagent-group-row.js";
+import { dispatchIsRunning, } from "../contract/dispatches.js";
+import { EMPTY_THREAD_DISPATCHES, newestRowForSession, threadDispatchLedgerFor, } from "../core/thread-dispatch-ledger.js";
 import { useCell } from "./use-store-cell.js";
-const POLL_INTERVAL_MS = 10_000;
-const MAX_CONSECUTIVE_READ_FAILURES = 3;
-const READ_BOUND_MS = 2 * POLL_INTERVAL_MS;
-const EMPTY_LEDGER = new Map();
-const RESUME_SUBAGENT_TOOL_NAME = "resume_subagent";
-function aResumeAwaitsLedgerTruth(rows, ledger) {
-    return rows.some((row) => {
-        if (row.kind !== "tool-call" ||
-            row.toolName !== RESUME_SUBAGENT_TOOL_NAME) {
-            return false;
-        }
-        const receipt = dispatchReceiptOf(row.result);
-        if (receipt === null || receipt.outcome === "already_settled") {
-            return false;
-        }
-        const dispatched = ledger.get(receipt.ordinal);
-        return dispatched === undefined || dispatchIsRunning(dispatched);
-    });
-}
-function newestRowForSession(map, childSessionId) {
-    let newest;
-    for (const dispatch of map.values()) {
-        if (dispatch.child_session_id !== childSessionId) {
-            continue;
-        }
-        if (newest === undefined || dispatch.ordinal > newest.ordinal) {
-            newest = dispatch;
-        }
-    }
-    return newest;
-}
-function anySubagentStillRunning(rows, ledger) {
-    return rows.some((row) => row.kind === "subagent-group" &&
-        row.entries.some((entry) => entry.receipt != null &&
-            resolvedSubagentEntryOf(entry, ledger).running));
-}
-class ThreadDispatchLedger {
-    session;
-    cell = new ObservableCell(null);
-    demands = new Map();
-    timer = null;
-    timerThreadId = null;
-    busy = false;
-    readThreadId = null;
-    pendingThreadId = null;
-    failedThreadId = null;
-    consecutiveFailures = 0;
-    constructor(session) {
-        this.session = session;
-    }
-    settleListeners = new Map();
-    setSettleListener(token, listener) {
-        if (listener === null) {
-            this.settleListeners.delete(token);
-        }
-        else {
-            this.settleListeners.set(token, listener);
-        }
-    }
-    pauseListeners = new Map();
-    setPauseListener(token, listener) {
-        if (listener === null) {
-            this.pauseListeners.delete(token);
-        }
-        else {
-            this.pauseListeners.set(token, listener);
-        }
-    }
-    setDemand(token, demand) {
-        if (demand === null) {
-            this.demands.delete(token);
-        }
-        else {
-            this.demands.set(token, demand);
-        }
-        this._reconcile();
-    }
-    refresh(threadId) {
-        if (!this.busy) {
-            return this._readOnce(threadId);
-        }
-        if (this.followUp === null || this.followUpThreadId !== threadId) {
-            this.followUpThreadId = threadId;
-            this.followUp = (this.flight ?? Promise.resolve()).then(() => {
-                this.followUp = null;
-                this.followUpThreadId = null;
-                return this._readOnce(threadId);
-            });
-        }
-        return this.followUp;
-    }
-    followUp = null;
-    followUpThreadId = null;
-    _reconcile() {
-        let threadId = null;
-        let delegated = false;
-        let stillMoving = false;
-        for (const demand of this.demands.values()) {
-            threadId ??= demand.threadId;
-            delegated ||= demand.delegated;
-            stillMoving ||= demand.stillMoving;
-        }
-        if (this.pendingThreadId !== null && this.pendingThreadId !== threadId) {
-            this.pendingThreadId = null;
-        }
-        if (threadId === null || !delegated) {
-            this._stopTimer();
-            return;
-        }
-        if (this.readThreadId !== threadId) {
-            void this._readOnce(threadId);
-        }
-        if (!stillMoving) {
-            this._stopTimer();
-            return;
-        }
-        if (this.timer === null || this.timerThreadId !== threadId) {
-            this._stopTimer();
-            void this._readOnce(threadId);
-            this.timerThreadId = threadId;
-            this.timer = window.setInterval(() => {
-                void this._readOnce(threadId);
-            }, POLL_INTERVAL_MS);
-        }
-    }
-    _sameAsCurrent(next) {
-        const current = this.cell.get();
-        if (current?.threadId !== next.threadId) {
-            return false;
-        }
-        if (current.map.size !== next.map.size) {
-            return false;
-        }
-        for (const [ordinal, dispatch] of next.map) {
-            const held = current.map.get(ordinal);
-            if (held?.status !== dispatch.status ||
-                held.error !== dispatch.error ||
-                held.updated_at !== dispatch.updated_at) {
-                return false;
-            }
-        }
-        return true;
-    }
-    _stopTimer() {
-        if (this.timer !== null) {
-            window.clearInterval(this.timer);
-            this.timer = null;
-            this.timerThreadId = null;
-        }
-    }
-    _readOnce(threadId) {
-        if (this.busy) {
-            if (threadId !== this.readThreadId) {
-                this.pendingThreadId = threadId;
-            }
-            return this.flight ?? Promise.resolve();
-        }
-        this.busy = true;
-        this.readThreadId = threadId;
-        this.generation += 1;
-        const generation = this.generation;
-        let settleFlight;
-        const flight = new Promise((resolve) => {
-            settleFlight = resolve;
-        });
-        this.flight = flight;
-        window.setTimeout(() => {
-            this._releaseBoundedOutRead(threadId, generation);
-            settleFlight();
-        }, READ_BOUND_MS);
-        void this._read(threadId, generation, settleFlight);
-        return flight;
-    }
-    flight = null;
-    generation = 0;
-    _releaseBoundedOutRead(threadId, generation) {
-        if (generation !== this.generation || !this.busy) {
-            return;
-        }
-        this.generation += 1;
-        this.busy = false;
-        this.flight = null;
-        this._noteReadFailure(threadId);
-        this._replayParkedSwitch();
-    }
-    _noteReadFailure(threadId) {
-        this.consecutiveFailures =
-            this.failedThreadId === threadId ? this.consecutiveFailures + 1 : 1;
-        this.failedThreadId = threadId;
-        if (this.consecutiveFailures >= MAX_CONSECUTIVE_READ_FAILURES &&
-            this.timerThreadId === threadId) {
-            this._stopTimer();
-        }
-        if (this.cell.get()?.threadId !== threadId) {
-            this.readThreadId = null;
-        }
-    }
-    _replayParkedSwitch() {
-        const pending = this.pendingThreadId;
-        this.pendingThreadId = null;
-        if (pending !== null && pending !== this.readThreadId) {
-            void this._readOnce(pending);
-        }
-    }
-    adoptedThrough = 0;
-    async _read(threadId, generation, settleFlight) {
-        const live = () => generation === this.generation;
-        try {
-            const dispatches = await listThreadDispatches(this.session, threadId);
-            const adopts = live() ||
-                (generation > this.adoptedThrough &&
-                    (this.readThreadId === threadId || this.readThreadId === null));
-            if (!adopts) {
-                if (this.failedThreadId === threadId) {
-                    this.failedThreadId = null;
-                    this.consecutiveFailures = 0;
-                }
-                return;
-            }
-            this.readThreadId ??= threadId;
-            this.adoptedThrough = generation;
-            const previous = this.cell.get();
-            const next = {
-                threadId,
-                map: new Map(dispatches.map((dispatch) => [dispatch.ordinal, dispatch])),
-            };
-            if (!this._sameAsCurrent(next)) {
-                this.cell.set(next);
-            }
-            this.failedThreadId = null;
-            this.consecutiveFailures = 0;
-            if (_observedASettle(previous, next)) {
-                _fireEach(this.settleListeners);
-            }
-            if (_observedAPause(previous, next)) {
-                _fireEach(this.pauseListeners);
-            }
-        }
-        catch {
-            if (!live()) {
-                return;
-            }
-            this._noteReadFailure(threadId);
-        }
-        finally {
-            if (live()) {
-                this.busy = false;
-                this.flight = null;
-                settleFlight();
-                this._replayParkedSwitch();
-            }
-        }
-    }
-}
-function _fireEach(listeners) {
-    for (const listener of new Set(listeners.values())) {
-        try {
-            listener();
-        }
-        catch {
-        }
-    }
-}
-function _observedAPause(previous, next) {
-    const comparable = previous?.threadId === next.threadId ? previous : null;
-    for (const [ordinal, dispatch] of next.map) {
-        if (!dispatchIsPaused(dispatch)) {
-            continue;
-        }
-        const held = comparable?.map.get(ordinal);
-        if (held === undefined ||
-            !dispatchIsPaused(held) ||
-            held.updated_at !== dispatch.updated_at) {
-            return true;
-        }
-    }
-    return false;
-}
-function _observedASettle(previous, next) {
-    if (previous?.threadId !== next.threadId) {
-        return false;
-    }
-    for (const [ordinal, dispatch] of next.map) {
-        if (dispatchIsRunning(dispatch)) {
-            continue;
-        }
-        const held = previous.map.get(ordinal);
-        if (held === undefined || dispatchIsRunning(held)) {
-            return true;
-        }
-    }
-    return false;
-}
-const _ledgers = new WeakMap();
-function _ledgerFor(session) {
-    let ledger = _ledgers.get(session);
-    if (ledger === undefined) {
-        ledger = new ThreadDispatchLedger(session);
-        _ledgers.set(session, ledger);
-    }
-    return ledger;
-}
-export function useThreadDispatches(session, threadId, rows, onDispatchSettled, onDispatchPaused) {
-    const ledger = _ledgerFor(session);
-    const read = useCell(ledger.cell);
-    const map = read !== null && read.threadId === threadId ? read.map : EMPTY_LEDGER;
-    const delegated = useMemo(() => rows.some((row) => row.kind === "subagent-group") ||
-        aResumeAwaitsLedgerTruth(rows, EMPTY_LEDGER), [rows]);
-    const stillMoving = useMemo(() => anySubagentStillRunning(rows, map) || aResumeAwaitsLedgerTruth(rows, map), [rows, map]);
-    const token = useMemo(() => ({}), []);
-    useEffect(() => {
-        if (threadId === null) {
-            return;
-        }
-        ledger.setDemand(token, { threadId, delegated, stillMoving });
-        return () => {
-            ledger.setDemand(token, null);
-        };
-    }, [ledger, token, threadId, delegated, stillMoving]);
-    useEffect(() => {
-        if (onDispatchSettled === undefined) {
-            return;
-        }
-        ledger.setSettleListener(token, onDispatchSettled);
-        return () => {
-            ledger.setSettleListener(token, null);
-        };
-    }, [ledger, token, onDispatchSettled]);
-    useEffect(() => {
-        if (onDispatchPaused === undefined) {
-            return;
-        }
-        ledger.setPauseListener(token, onDispatchPaused);
-        return () => {
-            ledger.setPauseListener(token, null);
-        };
-    }, [ledger, token, onDispatchPaused]);
-    const staleDeliveredOrdinals = useMemo(() => {
-        const delivered = new Set();
-        for (const row of rows) {
-            if (row.kind === "subagent-delivery") {
-                for (const result of row.results) {
-                    delivered.add(result.ordinal);
-                }
-            }
-        }
-        return [...delivered]
-            .filter((ordinal) => {
-            const ledgerRow = map.get(ordinal);
-            return ledgerRow !== undefined && dispatchIsRunning(ledgerRow);
-        })
-            .sort((a, b) => a - b)
-            .join(",");
-    }, [rows, map]);
-    useEffect(() => {
-        if (threadId !== null && staleDeliveredOrdinals !== "") {
-            void ledger.refresh(threadId);
-        }
-    }, [ledger, threadId, staleDeliveredOrdinals]);
-    return map;
+export function useThreadDispatches(session, threadId) {
+    const read = useCell(threadDispatchLedgerFor(session).cell);
+    return read !== null && read.threadId === threadId
+        ? read.map
+        : EMPTY_THREAD_DISPATCHES;
 }
 export function useChildDispatch(session, threadId, childSessionId) {
-    const ledger = _ledgerFor(session);
+    const ledger = threadDispatchLedgerFor(session);
     const read = useCell(ledger.cell);
     const dispatch = read !== null && read.threadId === threadId
         ? newestRowForSession(read.map, childSessionId)

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

@@ -4,7 +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";
+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, {

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

@@ -1,19 +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 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 {
+    /**
+     * 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[];
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * True while the newest turn has not finished, including while it is paused
+     * waiting for the user's approval or answer.
+     */
     turnOpen: boolean;
+    /**
+     * 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 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>;
 }
+/**
+ * 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?: {
     surface?: string;
 }): TranscriptSurface;

package/dist/components/use-transcript.js

@@ -2,14 +2,18 @@
 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";
+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);
@@ -24,7 +28,8 @@ export function useTranscript(options) {
     const running = runReadsAsWorking(activity.newestTurnStatus, decisionsPending);
     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,

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

@@ -1,26 +1,104 @@
+/** 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 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 cookies and
+     * headers adapters send it with Content-Type application/json.
+     */
     body?: unknown;
 }
+/**
+ * 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;
 }
+/**
+ * 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 - 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;

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;

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";

package/dist/contract/identity.d.ts

@@ -1 +1 @@
-export type { CurrentVisitorResponse as WhoamiResponse, EndUserIdentity, MintVisitorTokenRequest, MintVisitorTokenResponse, PublishableKeyMode, VisitorTier, } from "../generated/models/index.js";
+export type { MintVisitorTokenRequest, MintVisitorTokenResponse, VisitorTier, } from "../generated/models/index.js";

package/dist/contract/subscriptions.d.ts

@@ -1,6 +1,6 @@
 import type { SubscriptionProvider } from "../generated/models/index.js";
-export type { BeginSubscriptionAuthorizationResponse as SubscriptionAuthorization, CompleteSubscriptionAuthorizationRequest as SubscriptionAuthorizationCompletionRequest, CompleteSubscriptionAuthorizationResponse as SubscriptionAuthorizationCompletion, ServingSubscriptionStatus as SubscriptionStatus, SubscriptionCredentialState, SubscriptionProvider, } from "../generated/models/index.js";
-export declare const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+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;

package/dist/contract/subscriptions.js

@@ -1,4 +1,4 @@
-export const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
 export function subscriptionConnectMessageOf(event, serverOrigin, provider) {
     if (event.origin !== serverOrigin || event.source === null) {
         return null;