@teaflask/assistant 0.0.0 → 0.6.0

package/dist/generated/serving.js

@@ -0,0 +1,265 @@
+import { servingFetch } from "../transport/serving-fetch.js";
+export const getMintVisitorTokenUrl = () => {
+    return `/serving/v1/visitor-tokens`;
+};
+export const mintVisitorToken = async (mintVisitorTokenRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getMintVisitorTokenUrl(), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(mintVisitorTokenRequest),
+    });
+};
+export const getReadCurrentVisitorUrl = () => {
+    return `/serving/v1/whoami`;
+};
+export const readCurrentVisitor = async (options) => {
+    return servingFetch(getReadCurrentVisitorUrl(), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getReadAssistantConfigUrl = () => {
+    return `/serving/v1/assistant-config`;
+};
+export const readAssistantConfig = async (options) => {
+    return servingFetch(getReadAssistantConfigUrl(), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getSendServingAssistantMessageUrl = () => {
+    return `/serving/v1/assistant-threads/messages`;
+};
+export const sendServingAssistantMessage = async (sendServingAssistantMessageRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getSendServingAssistantMessageUrl(), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(sendServingAssistantMessageRequest),
+    });
+};
+export const getListServingAssistantThreadsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `/serving/v1/assistant-threads?${stringifiedParams}`
+        : `/serving/v1/assistant-threads`;
+};
+export const listServingAssistantThreads = async (params, options) => {
+    return servingFetch(getListServingAssistantThreadsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getGetServingAssistantThreadUrl = (threadId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `/serving/v1/assistant-threads/${threadId}?${stringifiedParams}`
+        : `/serving/v1/assistant-threads/${threadId}`;
+};
+export const getServingAssistantThread = async (threadId, params, options) => {
+    return servingFetch(getGetServingAssistantThreadUrl(threadId, params), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getListServingAssistantThreadDispatchesUrl = (threadId) => {
+    return `/serving/v1/assistant-threads/${threadId}/dispatches`;
+};
+export const listServingAssistantThreadDispatches = async (threadId, options) => {
+    return servingFetch(getListServingAssistantThreadDispatchesUrl(threadId), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getResolveServingAssistantTurnApprovalUrl = (threadId, turnId) => {
+    return `/serving/v1/assistant-threads/${threadId}/turns/${turnId}/approval`;
+};
+export const resolveServingAssistantTurnApproval = async (threadId, turnId, resolveServingTurnApprovalRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getResolveServingAssistantTurnApprovalUrl(threadId, turnId), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(resolveServingTurnApprovalRequest),
+    });
+};
+export const getResolveServingAssistantTurnToolResultsUrl = (threadId, turnId) => {
+    return `/serving/v1/assistant-threads/${threadId}/turns/${turnId}/tool-results`;
+};
+export const resolveServingAssistantTurnToolResults = async (threadId, turnId, resolveServingTurnToolResultsRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getResolveServingAssistantTurnToolResultsUrl(threadId, turnId), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(resolveServingTurnToolResultsRequest),
+    });
+};
+export const getStopServingAssistantTurnUrl = (threadId) => {
+    return `/serving/v1/assistant-threads/${threadId}/stop`;
+};
+export const stopServingAssistantTurn = async (threadId, options) => {
+    return servingFetch(getStopServingAssistantTurnUrl(threadId), {
+        ...options,
+        method: "POST",
+    });
+};
+export const getCreateServingAttachmentUploadUrl = () => {
+    return `/serving/v1/assistant-attachments`;
+};
+export const createServingAttachmentUpload = async (createServingAttachmentUploadRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getCreateServingAttachmentUploadUrl(), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(createServingAttachmentUploadRequest),
+    });
+};
+export const getFinalizeServingAttachmentUrl = (attachmentId) => {
+    return `/serving/v1/assistant-attachments/${attachmentId}/finalize`;
+};
+export const finalizeServingAttachment = async (attachmentId, options) => {
+    return servingFetch(getFinalizeServingAttachmentUrl(attachmentId), {
+        ...options,
+        method: "POST",
+    });
+};
+export const getGetServingAttachmentDownloadUrlUrl = (attachmentId) => {
+    return `/serving/v1/assistant-attachments/${attachmentId}/download-url`;
+};
+export const getServingAttachmentDownloadUrl = async (attachmentId, options) => {
+    return servingFetch(getGetServingAttachmentDownloadUrlUrl(attachmentId), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getListServingSubscriptionsUrl = () => {
+    return `/serving/v1/subscriptions`;
+};
+export const listServingSubscriptions = async (options) => {
+    return servingFetch(getListServingSubscriptionsUrl(), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getBeginSubscriptionAuthorizationUrl = (provider) => {
+    return `/serving/v1/subscriptions/${provider}/authorizations`;
+};
+export const beginSubscriptionAuthorization = async (provider, options) => {
+    return servingFetch(getBeginSubscriptionAuthorizationUrl(provider), {
+        ...options,
+        method: "POST",
+    });
+};
+export const getCompleteSubscriptionAuthorizationUrl = (provider) => {
+    return `/serving/v1/subscriptions/${provider}/authorizations/complete`;
+};
+export const completeSubscriptionAuthorization = async (provider, completeSubscriptionAuthorizationRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Array.isArray(h))
+            return Object.fromEntries(h);
+        return h;
+    };
+    return servingFetch(getCompleteSubscriptionAuthorizationUrl(provider), {
+        ...options,
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...getHeaders(options?.headers),
+        },
+        body: JSON.stringify(completeSubscriptionAuthorizationRequest),
+    });
+};
+export const getRecheckSubscriptionUrl = (provider) => {
+    return `/serving/v1/subscriptions/${provider}/recheck`;
+};
+export const recheckSubscription = async (provider, options) => {
+    return servingFetch(getRecheckSubscriptionUrl(provider), {
+        ...options,
+        method: "POST",
+    });
+};
+export const getDisconnectSubscriptionUrl = (provider) => {
+    return `/serving/v1/subscriptions/${provider}`;
+};
+export const disconnectSubscription = async (provider, options) => {
+    return servingFetch(getDisconnectSubscriptionUrl(provider), {
+        ...options,
+        method: "DELETE",
+    });
+};

package/dist/headless.d.ts

@@ -0,0 +1,40 @@
+export { TeaflaskAssistantProvider, type TeaflaskAssistantAnonymousProps, type TeaflaskAssistantIdentityProps, type TeaflaskAssistantProviderBaseProps, type TeaflaskAssistantProviderProps, } from "./components/teaflask-assistant-provider.js";
+export type { AssistantTheme, AssistantThemeDarkTokens, AssistantThemeMode, AssistantThemeTokens, } from "./appearance/theme.js";
+export type { ActionsAdapter, ActionIntent, ActionIntentAction, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
+export type { ApprovalSubmitTelemetryEvent, AssistantTelemetryEvent, StreamFailedTelemetryEvent, } from "./contract/telemetry.js";
+export type { AssistantSuggestion, AssistantSuggestionInput, AssistantSuggestionKind, } from "./components/conversation-view.js";
+export type { IconAdapter, JsonSchema, ToolViewAdapter, ToolViewCall, ToolViewInstance, ToolViewProps, ToolViewRegistration, ToolViewRegistry, } from "./core/tool-view.js";
+export { useAssistantConversation, type AssistantConversation, } from "./components/use-assistant-conversation.js";
+export { useConversation, type ComposerContract, } from "./components/conversation-context.js";
+export { useApprovals, type ApprovalSurface, } from "./components/approval-context.js";
+export { useElicitations, type ElicitationSurface, } from "./components/elicitation-context.js";
+export { useCell } from "./components/use-store-cell.js";
+export type { ReadonlyCell } from "./core/observable-cell.js";
+export type { ApprovalCardModel } from "./core/approval-inbox.js";
+export type { ActiveConversation, ApprovalDecisionInput, AttachmentDraft, ComposerInput, ComposerModelPick, } from "./core/conversation-store.js";
+export type { ServingAttachment, ThreadModelPick, TurnAttachment, } from "./contract/threads.js";
+export type { ServedThinkingEffort } from "./contract/assistant-config.js";
+export type { ElicitationCardModel, QuestionSetCardModel, } from "./core/elicitation-cards.js";
+export type { QuestionModel, QuestionOptionModel, } from "./core/elicitation-pickers.js";
+export type { QuestionAnswerDraft, QuestionDraftStore, QuestionSetDraft, } from "./core/question-drafts.js";
+export type { PendingDecisionGap } from "./core/pending-decision-gap.js";
+export type { ServingAssistantThread } from "./contract/threads.js";
+export { ServingApiError } from "./transport/serving-error.js";
+export type { ServingErrorCodeOnTheWire } from "./contract/errors.js";
+export { useTranscript, type TranscriptSurface, } from "./components/use-transcript.js";
+export { transcriptRowsOf, withPendingUserEcho, type AssistantTextRow, type PendingUserEcho, type ReasoningRow, type SubagentDeliveryRow, type ToolCallRow, type TranscriptRow, type TurnFailedReceiptsRow, type UserMessageRow, } from "./core/transcript-rows.js";
+export type { Message } from "@ag-ui/core";
+export type { MarkerAnchorsSnapshot } from "./core/connection-epoch.js";
+export type { DispatchReceipt, SubagentGroupEntry, SubagentGroupRow, } from "./core/subagent-rows.js";
+export type { AnchoredTurnFailReceipts } from "./core/turn-failed-anchors.js";
+export type { AnchoredReceipts } from "./core/receipt-anchors.js";
+export type { DeliveredResult } from "./core/subagent-delivery-anchors.js";
+export type { MemoryUpdated } from "./core/memory-provenance-anchors.js";
+export type { BlockTiming } from "./core/segment-timing.js";
+export type { ToolCallDisplay, ToolCallState, } from "./core/tool-call-display.js";
+export type { ToolCallSchemas } from "./core/tool-schema-anchors.js";
+export type { TurnUsage } from "./core/turn-usage-anchors.js";
+export type { AssistantActivityResult, AssistantActivitySnapshot, } from "./core/activity.js";
+export type { TurnStatus } from "./contract/threads.js";
+export type { UserTurnMeta } from "./core/user-turn-ledger.js";
+export { resetAssistant } from "./persistence/stored-thread.js";

package/dist/headless.js

@@ -0,0 +1,10 @@
+export { TeaflaskAssistantProvider, } from "./components/teaflask-assistant-provider.js";
+export { useAssistantConversation, } from "./components/use-assistant-conversation.js";
+export { useConversation, } from "./components/conversation-context.js";
+export { useApprovals, } from "./components/approval-context.js";
+export { useElicitations, } from "./components/elicitation-context.js";
+export { useCell } from "./components/use-store-cell.js";
+export { ServingApiError } from "./transport/serving-error.js";
+export { useTranscript, } from "./components/use-transcript.js";
+export { transcriptRowsOf, withPendingUserEcho, } from "./core/transcript-rows.js";
+export { resetAssistant } from "./persistence/stored-thread.js";

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export type { AssistantTheme, AssistantThemeDarkTokens, AssistantThemeMode, AssistantThemeTokens, } from "./appearance/theme.js";
+export { TeaflaskAssistantProvider, type TeaflaskAssistantAnonymousProps, type TeaflaskAssistantIdentityProps, type TeaflaskAssistantProviderBaseProps, type TeaflaskAssistantProviderProps, } from "./components/teaflask-assistant-provider.js";
+export { TeaflaskAssistant, type TeaflaskAssistantHandle, type TeaflaskAssistantProps, type TeaflaskAssistantRootProps, } from "./components/teaflask-assistant.js";
+export { AssistantPage, type AssistantChrome, type AssistantPageProps, } from "./components/assistant-page.js";
+export type { AssistantSuggestion, AssistantSuggestionInput, AssistantSuggestionKind, } from "./components/conversation-view.js";
+export { AssistantPalette, type AssistantPaletteProps, } from "./components/assistant-palette.js";
+export { useAssistantActivity } from "./components/use-assistant-activity.js";
+export type { AssistantActivityResult, AssistantActivitySnapshot, } from "./core/activity.js";
+export type { PendingDecisionGap } from "./core/pending-decision-gap.js";
+export { resetAssistant } from "./persistence/stored-thread.js";
+export { ServingApiError } from "./transport/serving-error.js";
+export type { ActionIntent, ActionIntentAction, ActionsAdapter, CookiesActionsAdapter, HeadersActionsAdapter, RequestActionsAdapter, } from "./contract/actions-adapter.js";
+export type { ServingErrorBody, ServingErrorCode, ServingErrorCodeOnTheWire, ServingErrorEnvelope, } from "./contract/errors.js";
+export type { EndUserIdentity, MintVisitorTokenRequest, MintVisitorTokenResponse, PublishableKeyMode, VisitorTier, WhoamiResponse, } from "./contract/identity.js";
+export { SUBSCRIPTION_CONNECT_MESSAGE_TYPE, subscriptionConnectMessageOf, type SubscriptionAuthorization, type SubscriptionAuthorizationCompletion, type SubscriptionAuthorizationCompletionRequest, type SubscriptionConnectMessage, type SubscriptionCredentialState, type SubscriptionProvider, type SubscriptionStatus, } from "./contract/subscriptions.js";
+export { ASSISTANT_MESSAGE_MAX_CHARS, type ApprovalDelivery, type AssistantThreadDetailResponse, type ResolveTurnApprovalRequest, type ResolveTurnApprovalResponse, type SendAssistantMessageRequest, type SendAssistantMessageResponse, type ServingAssistantThread, type ServingAssistantTurn, type TurnApprovalDecision, type TurnStatus, } from "./contract/threads.js";
+export { APPROVAL_REQUESTED_EVENT_NAME, MEMORY_UPDATED_EVENT_NAME, RUN_RESUMED_EVENT_NAME, TURN_USAGE_RECORDED_EVENT_NAME, type ApprovalRequestedPayload, type AssistantStreamEventType, type RunResumedPayload, } from "./contract/events.js";
+export { activeFoldElapsedOf, settledFoldDurationOf, type BlockTiming, type SegmentDuration, } from "./core/segment-timing.js";
+export { usageIsFinal, type TurnUsage } from "./core/turn-usage-anchors.js";
+export type { MemoryUpdated } from "./core/memory-provenance-anchors.js";
+export type { ApprovalSubmitDropReason, ApprovalSubmitTelemetryEvent, AssistantTelemetryEvent, StreamFailedTelemetryEvent, StreamFailureClass, } from "./contract/telemetry.js";
+export type { ToolCallDisplay, ToolCallState, ToolCallViewModel, } from "./core/tool-call-display.js";
+export { TOOL_CALL_ICONS, toolCallPresentationOf, type ToolCallIcon, type ToolCallPresentation, } from "./core/tool-call-presentation.js";
+export { actionToolName, actionToolViews, resolvedToolViewsOf, type IconAdapter, type JsonSchema, type ResolvedToolView, type ResolvedToolViewIcon, type ToolViewAdapter, type ToolViewCall, type ToolViewInstance, type ToolViewProps, type ToolViewRegistration, type ToolViewRegistry, type ToolViewResolution, type ToolViewThemeMode, } from "./core/tool-view.js";
+export { reactToolView } from "./components/react-tool-view.js";
+export { ToolViewBadge, ToolViewBody, ToolViewBones, ToolViewScroll, ToolViewTitle, ToolViewCaption, ToolViewCard, ToolViewFacts, ToolViewNote, ToolViewRow, } from "./components/tool-views/parts.js";
+export { actionEnvelopeOf, actionFailureOf, boneRows, captionRow, card, factRows, humanFailureSentenceOf, listRow, note, pane, recordOf, scrollRegion, terminal, settledOutcomeNoteOf, settledOutcomeNotesOf, settledWithResult, type ActionEnvelope, type ActionFailure, } from "./components/tool-views/view-dom.js";
+export { AssistantCompanion, type AssistantCompanionProps, } from "./components/assistant-companion.js";

package/dist/index.js

@@ -0,0 +1,18 @@
+export { TeaflaskAssistantProvider, } from "./components/teaflask-assistant-provider.js";
+export { TeaflaskAssistant, } from "./components/teaflask-assistant.js";
+export { AssistantPage, } from "./components/assistant-page.js";
+export { AssistantPalette, } from "./components/assistant-palette.js";
+export { useAssistantActivity } from "./components/use-assistant-activity.js";
+export { resetAssistant } from "./persistence/stored-thread.js";
+export { ServingApiError } from "./transport/serving-error.js";
+export { SUBSCRIPTION_CONNECT_MESSAGE_TYPE, subscriptionConnectMessageOf, } from "./contract/subscriptions.js";
+export { ASSISTANT_MESSAGE_MAX_CHARS, } from "./contract/threads.js";
+export { APPROVAL_REQUESTED_EVENT_NAME, MEMORY_UPDATED_EVENT_NAME, RUN_RESUMED_EVENT_NAME, TURN_USAGE_RECORDED_EVENT_NAME, } from "./contract/events.js";
+export { activeFoldElapsedOf, settledFoldDurationOf, } from "./core/segment-timing.js";
+export { usageIsFinal } from "./core/turn-usage-anchors.js";
+export { TOOL_CALL_ICONS, toolCallPresentationOf, } from "./core/tool-call-presentation.js";
+export { actionToolName, actionToolViews, resolvedToolViewsOf, } from "./core/tool-view.js";
+export { reactToolView } from "./components/react-tool-view.js";
+export { ToolViewBadge, ToolViewBody, ToolViewBones, ToolViewScroll, ToolViewTitle, ToolViewCaption, ToolViewCard, ToolViewFacts, ToolViewNote, ToolViewRow, } from "./components/tool-views/parts.js";
+export { actionEnvelopeOf, actionFailureOf, boneRows, captionRow, card, factRows, humanFailureSentenceOf, listRow, note, pane, recordOf, scrollRegion, terminal, settledOutcomeNoteOf, settledOutcomeNotesOf, settledWithResult, } from "./components/tool-views/view-dom.js";
+export { AssistantCompanion, } from "./components/assistant-companion.js";

package/dist/markdown.d.ts

@@ -0,0 +1,4 @@
+export { AssistantMarkdown } from "./components/markdown/assistant-markdown.js";
+export { PacedAssistantMarkdown } from "./components/markdown/paced-assistant-markdown.js";
+export { repairedStreamingMarkdown } from "./components/markdown/streaming-repair.js";
+export { usePacedReveal } from "./components/markdown/use-paced-reveal.js";

package/dist/markdown.js

@@ -0,0 +1,4 @@
+export { AssistantMarkdown } from "./components/markdown/assistant-markdown.js";
+export { PacedAssistantMarkdown } from "./components/markdown/paced-assistant-markdown.js";
+export { repairedStreamingMarkdown } from "./components/markdown/streaming-repair.js";
+export { usePacedReveal } from "./components/markdown/use-paced-reveal.js";

package/dist/persistence/execution-ledger.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionOutcome } from "../core/execution-handlers.js";
+export declare const UNKNOWN_OUTCOME: Extract<ExecutionOutcome, {
+    ok: false;
+}>;
+export declare function readExecutedOutcome(threadId: string, interruptId: string): ExecutionOutcome | null;
+export declare function recordExecutionClaimed(threadId: string, interruptId: string): void;
+export declare function recordExecutedOutcome(threadId: string, interruptId: string, outcome: ExecutionOutcome): void;

package/dist/persistence/execution-ledger.js

@@ -0,0 +1,85 @@
+export const UNKNOWN_OUTCOME = {
+    ok: false,
+    error: {
+        code: "execution_failed",
+        message: "The page was interrupted while performing this action, so its " +
+            "outcome is unknown. Tell the user what was being attempted and ask " +
+            "them to check whether it happened before anything is retried.",
+    },
+};
+const MAX_RECORDED_EXECUTIONS = 40;
+const memoryLedgers = new Map();
+export function readExecutedOutcome(threadId, interruptId) {
+    const record = _recordsFor(threadId).find((known) => known.interruptId === interruptId);
+    if (record === undefined) {
+        return null;
+    }
+    return record.outcome ?? UNKNOWN_OUTCOME;
+}
+export function recordExecutionClaimed(threadId, interruptId) {
+    const records = _recordsFor(threadId);
+    if (records.some((known) => known.interruptId === interruptId)) {
+        return;
+    }
+    records.push({ interruptId, outcome: null });
+    _writeRecords(threadId, records.slice(-MAX_RECORDED_EXECUTIONS));
+}
+export function recordExecutedOutcome(threadId, interruptId, outcome) {
+    const records = _recordsFor(threadId);
+    const known = records.find((record) => record.interruptId === interruptId);
+    if (known !== undefined) {
+        known.outcome = outcome;
+    }
+    else {
+        records.push({ interruptId, outcome });
+    }
+    _writeRecords(threadId, records.slice(-MAX_RECORDED_EXECUTIONS));
+}
+function _storageKeyFor(threadId) {
+    return `tf-assistant:executions:${threadId}`;
+}
+function _recordsFor(threadId) {
+    const remembered = memoryLedgers.get(threadId);
+    if (remembered !== undefined) {
+        return remembered;
+    }
+    const raw = _storage()?.getItem(_storageKeyFor(threadId)) ?? null;
+    return raw === null ? [] : _decodeRecords(raw);
+}
+function _writeRecords(threadId, records) {
+    memoryLedgers.set(threadId, records);
+    try {
+        _storage()?.setItem(_storageKeyFor(threadId), JSON.stringify(records));
+    }
+    catch {
+    }
+}
+function _storage() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    try {
+        return window.sessionStorage;
+    }
+    catch {
+        return null;
+    }
+}
+function _decodeRecords(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed.filter(_isLedgerRecord);
+        }
+    }
+    catch {
+    }
+    return [];
+}
+function _isLedgerRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "interruptId" in value &&
+        typeof value.interruptId === "string" &&
+        "outcome" in value);
+}

package/dist/persistence/panel-mode.d.ts

@@ -0,0 +1,6 @@
+export type PanelDock = "floating" | "sidebar";
+type PanelModeListener = () => void;
+export declare function readPanelMode(publishableKey: string): PanelDock;
+export declare function writePanelMode(publishableKey: string, mode: PanelDock): void;
+export declare function subscribePanelMode(listener: PanelModeListener): () => void;
+export {};

package/dist/persistence/panel-mode.js

@@ -0,0 +1,49 @@
+const _listeners = new Set();
+export function readPanelMode(publishableKey) {
+    try {
+        return _storage()?.getItem(_storageKeyFor(publishableKey)) === "sidebar"
+            ? "sidebar"
+            : "floating";
+    }
+    catch {
+        return "floating";
+    }
+}
+export function writePanelMode(publishableKey, mode) {
+    try {
+        if (mode === "sidebar") {
+            _storage()?.setItem(_storageKeyFor(publishableKey), "sidebar");
+        }
+        else {
+            _storage()?.removeItem(_storageKeyFor(publishableKey));
+        }
+    }
+    catch {
+    }
+    _notifyPanelModeChanged();
+}
+export function subscribePanelMode(listener) {
+    _listeners.add(listener);
+    return () => {
+        _listeners.delete(listener);
+    };
+}
+function _notifyPanelModeChanged() {
+    for (const listener of [..._listeners]) {
+        listener();
+    }
+}
+function _storageKeyFor(publishableKey) {
+    return `tf-assistant:${publishableKey}:panel-mode`;
+}
+function _storage() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    try {
+        return window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/persistence/plan-notice.d.ts

@@ -0,0 +1,3 @@
+import type { SubscriptionProvider } from "../contract/subscriptions.js";
+export declare function readPlanNoticeSeen(publishableKey: string, provider: SubscriptionProvider): boolean;
+export declare function writePlanNoticeSeen(publishableKey: string, provider: SubscriptionProvider): void;

package/dist/persistence/plan-notice.js

@@ -0,0 +1,30 @@
+const _SEEN = "seen";
+export function readPlanNoticeSeen(publishableKey, provider) {
+    try {
+        return (_storage()?.getItem(_storageKeyFor(publishableKey, provider)) === _SEEN);
+    }
+    catch {
+        return false;
+    }
+}
+export function writePlanNoticeSeen(publishableKey, provider) {
+    try {
+        _storage()?.setItem(_storageKeyFor(publishableKey, provider), _SEEN);
+    }
+    catch {
+    }
+}
+function _storageKeyFor(publishableKey, provider) {
+    return `tf-assistant:${publishableKey}:plan-notice-seen:${provider}`;
+}
+function _storage() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    try {
+        return window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/persistence/stored-thread.d.ts

@@ -0,0 +1,12 @@
+export interface StoredThread {
+    threadId: string;
+    identified: boolean;
+    userId?: string;
+}
+export declare function readStoredThread(publishableKey: string): StoredThread | null;
+export declare function readStoredThreadFor(publishableKey: string, userId: string | undefined): StoredThread | null;
+export declare function writeStoredThread(publishableKey: string, stored: StoredThread): void;
+export declare function clearStoredThread(publishableKey: string): void;
+export declare function resetAssistant(options: {
+    publishableKey: string;
+}): void;

package/dist/persistence/stored-thread.js

@@ -0,0 +1,67 @@
+export function readStoredThread(publishableKey) {
+    const raw = _storage()?.getItem(_storageKeyFor(publishableKey)) ?? null;
+    if (raw === null) {
+        return null;
+    }
+    return _decodeStoredThread(raw);
+}
+export function readStoredThreadFor(publishableKey, userId) {
+    const stored = readStoredThread(publishableKey);
+    if (!stored?.identified) {
+        return stored;
+    }
+    return userId !== undefined && stored.userId === userId ? stored : null;
+}
+export function writeStoredThread(publishableKey, stored) {
+    try {
+        _storage()?.setItem(_storageKeyFor(publishableKey), JSON.stringify(stored));
+    }
+    catch {
+    }
+}
+export function clearStoredThread(publishableKey) {
+    try {
+        _storage()?.removeItem(_storageKeyFor(publishableKey));
+    }
+    catch {
+    }
+}
+export function resetAssistant(options) {
+    clearStoredThread(options.publishableKey);
+}
+function _storageKeyFor(publishableKey) {
+    return `tf-assistant:${publishableKey}:thread`;
+}
+function _storage() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    try {
+        return window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+function _decodeStoredThread(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (_isStoredThread(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+function _isStoredThread(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "threadId" in value &&
+        typeof value.threadId === "string" &&
+        "identified" in value &&
+        typeof value.identified === "boolean" &&
+        (!("userId" in value) ||
+            value.userId === undefined ||
+            typeof value.userId === "string"));
+}

package/dist/reader/accessible-name.d.ts

@@ -0,0 +1,3 @@
+import type { LayoutProbe } from "./layout-probe.js";
+export type AccessibleNameCache = Map<Element, string>;
+export declare function accessibleNameOf(element: Element, probe: LayoutProbe, cache: AccessibleNameCache): string;