@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/approval-request-narrowing.js

@@ -0,0 +1,59 @@
+import { withoutStepCaption } from "./step-caption.js";
+export function coworkerApprovalRequestOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.ordinal !== "number" ||
+        typeof record.label !== "string" ||
+        typeof record.child_session_id !== "string") {
+        return null;
+    }
+    const card = approvalRequestedPayloadOf(record.card);
+    if (card === null) {
+        return null;
+    }
+    return {
+        ordinal: record.ordinal,
+        label: record.label,
+        childSessionId: record.child_session_id,
+        parked: record.parked === true,
+        card,
+    };
+}
+export function approvalRequestedPayloadOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.interrupt_id !== "string" || record.interrupt_id === "") {
+        return null;
+    }
+    if (typeof record.prompt !== "string") {
+        return null;
+    }
+    return {
+        interrupt_id: record.interrupt_id,
+        prompt: record.prompt,
+        tool_name: typeof record.tool_name === "string" ? record.tool_name : null,
+        tool_args: withoutStepCaption(recordOrEmpty(record.tool_args)),
+        tool_input_schema: recordOrNull(record.tool_input_schema),
+        tool_output_schema: recordOrNull(record.tool_output_schema),
+        tool_call_id: typeof record.tool_call_id === "string" ? record.tool_call_id : null,
+        round: typeof record.round === "number" ? record.round : 0,
+        gated: record.gated === true,
+        trust_available: record.trust_available === true,
+    };
+}
+function recordOrEmpty(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function recordOrNull(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}

package/dist/core/approval-resolved.d.ts

@@ -0,0 +1,7 @@
+export interface ApprovalResolved {
+    interruptId: string;
+    approved: boolean;
+    feedback?: string;
+    resolvedBy?: string;
+}
+export declare function approvalResolvedPayloadOf(value: unknown): ApprovalResolved | null;

package/dist/core/approval-resolved.js

@@ -0,0 +1,16 @@
+export function approvalResolvedPayloadOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const payload = value;
+    if (typeof payload.interrupt_id !== "string" ||
+        typeof payload.approved !== "boolean") {
+        return null;
+    }
+    return {
+        interruptId: payload.interrupt_id,
+        approved: payload.approved,
+        feedback: typeof payload.feedback === "string" ? payload.feedback : undefined,
+        resolvedBy: typeof payload.resolved_by === "string" ? payload.resolved_by : undefined,
+    };
+}

package/dist/core/assistant-prose.d.ts

@@ -0,0 +1,2 @@
+import type { Message } from "@ag-ui/core";
+export declare function newestAssistantProseIdOf(messages: readonly Message[]): string | null;

package/dist/core/assistant-prose.js

@@ -0,0 +1,11 @@
+export function newestAssistantProseIdOf(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.role === "assistant" &&
+            typeof message.content === "string" &&
+            message.content !== "") {
+            return message.id;
+        }
+    }
+    return null;
+}

package/dist/core/assistant-session-registry.d.ts

@@ -0,0 +1,51 @@
+import type { ServedAttachmentPolicy, ServedModelChoice, ServedSuggestionsConfig } from "../contract/assistant-config.js";
+import type { VisitorTier } from "../contract/identity.js";
+import type { SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
+import type { AssistantTelemetryEvent } from "../contract/telemetry.js";
+import type { ServingApiError } from "../transport/serving-error.js";
+import { TokenSession } from "../transport/token-session.js";
+import { type ConversationGate } from "./connect-gate.js";
+import { AssistantConversationStore, type HostCapabilities } from "./conversation-store.js";
+import { type ReadonlyCell } from "./observable-cell.js";
+export declare const DEFAULT_BASE_URL = "https://api.teaflask.com";
+export interface AssistantSessionSpec {
+    publishableKey: string;
+    baseUrl?: string;
+    userId?: string;
+}
+export interface AssistantSessionRegistrant {
+    resolveEndUserToken: (() => string | null | Promise<string | null>) | null;
+    hostCapabilitiesOf: () => HostCapabilities;
+    reportError: (error: Error) => void;
+    onTelemetry: ((event: AssistantTelemetryEvent) => void) | null;
+}
+export interface AssistantSessionEntry {
+    readonly session: TokenSession;
+    readonly store: AssistantConversationStore;
+    readonly tier: ReadonlyCell<VisitorTier | null>;
+    readonly setupError: ReadonlyCell<ServingApiError | null>;
+    readonly assistantConfig: ReadonlyCell<ServedSuggestionsConfig | null>;
+    readonly attachmentPolicy: ReadonlyCell<ServedAttachmentPolicy | null>;
+    readonly modelChoice: ReadonlyCell<ServedModelChoice | null>;
+    readonly configAnswered: ReadonlyCell<boolean>;
+    readonly ensureAssistantConfig: () => void;
+    readonly refreshAssistantConfig: () => void;
+    readonly conversationGate: ReadonlyCell<ConversationGate>;
+    readonly subscriptions: ReadonlyCell<SubscriptionStatus[] | null>;
+    readonly ensureSubscriptions: () => void;
+    readonly refreshSubscriptions: () => void;
+    readonly connectOpenRequested: ReadonlyCell<boolean>;
+    readonly requestSubscriptionConnect: () => void;
+    readonly acknowledgeSubscriptionConnect: () => void;
+    readonly planNoticeDue: ReadonlyCell<SubscriptionProvider | null>;
+    readonly notePlanSignedIn: (provider: SubscriptionProvider) => void;
+    readonly acknowledgePlanNotice: () => void;
+}
+export declare class AssistantSessionRegistry {
+    private readonly entries;
+    entryFor(requested: AssistantSessionSpec): AssistantSessionEntry;
+    retain(entry: AssistantSessionEntry, registrant: AssistantSessionRegistrant): () => void;
+    private _reviveIfSwept;
+    private _sweepIfStillUnretained;
+}
+export declare const assistantSessionRegistry: AssistantSessionRegistry;

package/dist/core/assistant-session-registry.js

@@ -0,0 +1,313 @@
+import { readStoredThread, writeStoredThread, } from "../persistence/stored-thread.js";
+import { getAssistantConfig, listSubscriptions, } from "../transport/serving-api.js";
+import { END_USER_ID_MISMATCH, TokenSession, } from "../transport/token-session.js";
+import { NO_GATE, gateOfProjection, gateOfRefusal, gatesEqual, } from "./connect-gate.js";
+import { AssistantConversationStore, } from "./conversation-store.js";
+import { namedUserIdOf } from "./identity-pair.js";
+import { ObservableCell } from "./observable-cell.js";
+export const DEFAULT_BASE_URL = "https://api.teaflask.com";
+class SessionEntry {
+    key;
+    session;
+    store;
+    tier;
+    setupError;
+    assistantConfig;
+    attachmentPolicy;
+    modelChoice;
+    configAnswered;
+    conversationGate;
+    subscriptions;
+    connectOpenRequested;
+    planNoticeDue;
+    registrations = new Set();
+    _endFirstRetainWait = null;
+    _everRetained = false;
+    _tierCell = new ObservableCell(null);
+    _setupErrorCell = new ObservableCell(null);
+    _assistantConfigCell = new ObservableCell(null);
+    _attachmentPolicyCell = new ObservableCell(null);
+    _modelChoiceCell = new ObservableCell(null);
+    _configAnsweredCell = new ObservableCell(false);
+    _conversationGateCell = new ObservableCell(NO_GATE);
+    _assistantConfigFetch = null;
+    _subscriptionsCell = new ObservableCell(null);
+    _subscriptionsFetch = null;
+    _connectOpenRequestedCell = new ObservableCell(false);
+    _planNoticeDueCell = new ObservableCell(null);
+    ensureAssistantConfig = () => {
+        this._assistantConfigFetch ??= this._fetchAssistantConfig();
+    };
+    refreshAssistantConfig = () => {
+        if (this._assistantConfigFetch !== null) {
+            this._assistantConfigFetch = this._fetchAssistantConfig();
+        }
+    };
+    _fetchAssistantConfig() {
+        const fetch = getAssistantConfig(this.session).then((config) => {
+            if (this._assistantConfigFetch === fetch) {
+                this._assistantConfigCell.set(config.suggestions);
+                this._attachmentPolicyCell.set(config.attachments ?? null);
+                this._modelChoiceCell.set(config.model_choice ?? null);
+                this._configAnsweredCell.set(true);
+                const gate = gateOfProjection(config.connect);
+                if (!gatesEqual(this._conversationGateCell.get(), gate)) {
+                    this._conversationGateCell.set(gate);
+                }
+            }
+        }, () => {
+            if (this._assistantConfigFetch === fetch) {
+                this._assistantConfigFetch = null;
+                this._configAnsweredCell.set(true);
+            }
+        });
+        return fetch;
+    }
+    ensureSubscriptions = () => {
+        this._subscriptionsFetch ??= this._fetchSubscriptions();
+    };
+    refreshSubscriptions = () => {
+        this._subscriptionsFetch = this._fetchSubscriptions();
+    };
+    requestSubscriptionConnect = () => {
+        this.refreshSubscriptions();
+        this._connectOpenRequestedCell.set(true);
+    };
+    acknowledgeSubscriptionConnect = () => {
+        this._connectOpenRequestedCell.set(false);
+    };
+    _onTurnSettled = () => {
+        this.refreshAssistantConfig();
+        if (this._tierCell.get() === "identified") {
+            this.refreshSubscriptions();
+        }
+    };
+    notePlanSignedIn = (provider) => {
+        this._planNoticeDueCell.set(provider);
+    };
+    acknowledgePlanNotice = () => {
+        this._planNoticeDueCell.set(null);
+    };
+    _fetchSubscriptions() {
+        const fetch = listSubscriptions(this.session).then((subscriptions) => {
+            if (this._subscriptionsFetch === fetch) {
+                this._subscriptionsCell.set(subscriptions);
+            }
+        }, () => {
+            if (this._subscriptionsFetch === fetch) {
+                this._subscriptionsFetch = null;
+            }
+        });
+        return fetch;
+    }
+    constructor(key, spec) {
+        this.key = key;
+        this.tier = this._tierCell;
+        this.setupError = this._setupErrorCell;
+        this.assistantConfig = this._assistantConfigCell;
+        this.attachmentPolicy = this._attachmentPolicyCell;
+        this.modelChoice = this._modelChoiceCell;
+        this.configAnswered = this._configAnsweredCell;
+        this.conversationGate = this._conversationGateCell;
+        this.subscriptions = this._subscriptionsCell;
+        this.connectOpenRequested = this._connectOpenRequestedCell;
+        this.planNoticeDue = this._planNoticeDueCell;
+        const publishableKey = spec.publishableKey;
+        const userId = spec.userId;
+        const identityProvided = userId !== undefined;
+        this.session = new TokenSession({
+            publishableKey,
+            baseUrl: _withoutTrailingSlash(spec.baseUrl ?? DEFAULT_BASE_URL),
+            getEndUserToken: identityProvided
+                ? () => this._resolveEndUserToken()
+                : undefined,
+            expectedEndUserId: userId,
+            claimThreadId: () => {
+                const stored = readStoredThread(publishableKey);
+                return stored !== null && !stored.identified ? stored.threadId : null;
+            },
+            onMinted: (minted) => {
+                const previousTier = this._tierCell.get();
+                this._setupErrorCell.set(null);
+                this._tierCell.set(minted.tier);
+                if (minted.tier === "identified") {
+                    _markStoredThreadIdentified(publishableKey, userId);
+                }
+                this.store.setTier(minted.tier);
+                if (previousTier !== null && previousTier !== minted.tier) {
+                    this.refreshAssistantConfig();
+                }
+            },
+            onMintFailed: (error) => {
+                if (_isSetupFailure(error)) {
+                    this._setupErrorCell.set(error);
+                }
+                this._reportToEveryRegistrant(error);
+            },
+        });
+        this.store = new AssistantConversationStore({
+            session: this.session,
+            publishableKey,
+            userId,
+            hostCapabilitiesOf: () => this._firstCapableRegistrantCapabilities(),
+            reportError: (error) => {
+                this._reportToEveryRegistrant(error);
+            },
+            onTelemetry: (event) => {
+                for (const registration of [...this.registrations]) {
+                    try {
+                        registration.registrant.onTelemetry?.(event);
+                    }
+                    catch (error) {
+                        this._reportToEveryRegistrant(_asError(error));
+                    }
+                }
+            },
+            onGateRefusal: (error) => {
+                const gate = gateOfRefusal(error);
+                if (gate !== null) {
+                    this._conversationGateCell.set(gate);
+                    this.refreshSubscriptions();
+                }
+            },
+            onTurnSettled: this._onTurnSettled,
+        });
+    }
+    _resolveEndUserToken() {
+        const vouch = this._vouchFromRegistrants();
+        if (vouch !== undefined) {
+            return vouch;
+        }
+        if (this._everRetained) {
+            return null;
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, FIRST_RETAIN_WAIT_MS);
+            this._endFirstRetainWait = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+        }).then(() => this._vouchFromRegistrants() ?? null);
+    }
+    _vouchFromRegistrants() {
+        for (const registration of this.registrations) {
+            const resolve = registration.registrant.resolveEndUserToken;
+            if (resolve !== null) {
+                return resolve();
+            }
+        }
+        return this.registrations.size === 0 ? undefined : null;
+    }
+    settleFirstRetain() {
+        this._everRetained = true;
+        this._endFirstRetainWait?.();
+        this._endFirstRetainWait = null;
+    }
+    _firstCapableRegistrantCapabilities() {
+        const merged = {
+            navigate: null,
+            executeActionIntent: null,
+        };
+        for (const registration of this.registrations) {
+            const capabilities = registration.registrant.hostCapabilitiesOf();
+            merged.navigate ??= capabilities.navigate;
+            merged.executeActionIntent ??= capabilities.executeActionIntent;
+        }
+        return merged;
+    }
+    _reportToEveryRegistrant(error) {
+        for (const registration of [...this.registrations]) {
+            try {
+                registration.registrant.reportError(error);
+            }
+            catch (hookFailure) {
+                console.warn("A host reportError callback threw while being handed an error:", hookFailure, "— the original error it was reporting:", error);
+            }
+        }
+    }
+}
+export class AssistantSessionRegistry {
+    entries = new Map();
+    entryFor(requested) {
+        const spec = _withNamedUser(requested);
+        const key = _identityKeyOf(spec);
+        const existing = this.entries.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const entry = new SessionEntry(key, spec);
+        this.entries.set(key, entry);
+        return entry;
+    }
+    retain(entry, registrant) {
+        if (!(entry instanceof SessionEntry)) {
+            throw new Error("Only entries resolved by entryFor() can be retained — construct nothing yourself.");
+        }
+        const registration = { registrant };
+        const firstRetain = entry.registrations.size === 0;
+        entry.registrations.add(registration);
+        entry.settleFirstRetain();
+        if (firstRetain) {
+            this._reviveIfSwept(entry);
+            entry.store.bootstrap();
+        }
+        return () => {
+            if (!entry.registrations.delete(registration)) {
+                return;
+            }
+            if (entry.registrations.size > 0) {
+                return;
+            }
+            queueMicrotask(() => {
+                this._sweepIfStillUnretained(entry);
+            });
+        };
+    }
+    _reviveIfSwept(entry) {
+        if (!this.entries.has(entry.key)) {
+            this.entries.set(entry.key, entry);
+        }
+    }
+    _sweepIfStillUnretained(entry) {
+        if (entry.registrations.size > 0) {
+            return;
+        }
+        if (this.entries.get(entry.key) === entry) {
+            this.entries.delete(entry.key);
+        }
+        entry.store.dispose();
+        entry.session.dispose();
+    }
+}
+export const assistantSessionRegistry = new AssistantSessionRegistry();
+const FIRST_RETAIN_WAIT_MS = 2_000;
+function _withNamedUser(spec) {
+    return { ...spec, userId: namedUserIdOf(spec.userId) };
+}
+function _identityKeyOf(spec) {
+    const userId = spec.userId;
+    return [
+        spec.publishableKey,
+        _withoutTrailingSlash(spec.baseUrl ?? DEFAULT_BASE_URL),
+        userId === undefined ? "anonymous" : "identified",
+        userId ?? "",
+    ].join("\u0000");
+}
+function _isSetupFailure(error) {
+    return (error.code === "PUBLISHABLE_KEY_INVALID" ||
+        error.code === "ORIGIN_NOT_ALLOWED" ||
+        error.code === "END_USER_TOKEN_INVALID" ||
+        error.code === END_USER_ID_MISMATCH);
+}
+function _markStoredThreadIdentified(publishableKey, userId) {
+    const stored = readStoredThread(publishableKey);
+    if (stored !== null && !stored.identified) {
+        writeStoredThread(publishableKey, { ...stored, identified: true, userId });
+    }
+}
+function _withoutTrailingSlash(baseUrl) {
+    return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+function _asError(thrown) {
+    return thrown instanceof Error ? thrown : new Error(String(thrown));
+}

package/dist/core/attachment-uploads.d.ts

@@ -0,0 +1,5 @@
+import type { ServingAttachment } from "../contract/threads.js";
+import type { MintedDownloadUrl } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function uploadAttachmentFromStore(store: AssistantConversationStore, file: File): Promise<ServingAttachment>;
+export declare function mintAttachmentDownloadUrlFromStore(store: AssistantConversationStore, attachmentId: string): Promise<MintedDownloadUrl>;

package/dist/core/attachment-uploads.js

@@ -0,0 +1,22 @@
+import { createAttachmentUpload, finalizeAttachment, getAttachmentDownloadUrl, putFileToUploadUrl, } from "../transport/serving-api.js";
+export async function uploadAttachmentFromStore(store, file) {
+    const intent = await createAttachmentUpload(store.deps.session, {
+        filename: file.name !== "" ? file.name : "attachment",
+        byte_size: file.size,
+    });
+    await putFileToUploadUrl(intent.upload_url, file);
+    return finalizeAttachment(store.deps.session, intent.attachment.id);
+}
+export async function mintAttachmentDownloadUrlFromStore(store, attachmentId) {
+    const cached = store._downloadUrls.get(attachmentId);
+    if (cached !== undefined && cached.expiresAtMs > Date.now()) {
+        return cached;
+    }
+    const fresh = await getAttachmentDownloadUrl(store.deps.session, attachmentId);
+    const minted = {
+        url: fresh.url,
+        expiresAtMs: Date.now() + (fresh.expires_in_seconds - 30) * 1000,
+    };
+    store._downloadUrls.set(attachmentId, minted);
+    return minted;
+}

package/dist/core/block-timing-anchors.d.ts

@@ -0,0 +1,5 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+import type { BlockTiming } from "./segment-timing.js";
+export declare function foldBlockTimingObserved(timings: Map<string, BlockTiming>, blockId: string, observedAtMs: number): boolean;
+export declare function wellFormedBlockTimingAnchorsOf(stored: ReadonlyMap<string, BlockTiming>): ReadonlyMap<string, BlockTiming>;
+export declare function blockTimingRecorder(onTimingObserved: (blockId: string, observedAtMs: number) => void): AgentSubscriber;

package/dist/core/block-timing-anchors.js

@@ -0,0 +1,93 @@
+import { EventType } from "@ag-ui/core";
+export function foldBlockTimingObserved(timings, blockId, observedAtMs) {
+    const existing = timings.get(blockId);
+    if (existing === undefined) {
+        timings.set(blockId, {
+            startedAtMs: observedAtMs,
+            settledAtMs: observedAtMs,
+        });
+        return true;
+    }
+    const startedAtMs = existing.startedAtMs === null
+        ? observedAtMs
+        : Math.min(existing.startedAtMs, observedAtMs);
+    const settledAtMs = existing.settledAtMs === null
+        ? observedAtMs
+        : Math.max(existing.settledAtMs, observedAtMs);
+    if (startedAtMs === existing.startedAtMs &&
+        settledAtMs === existing.settledAtMs) {
+        return false;
+    }
+    timings.set(blockId, { startedAtMs, settledAtMs });
+    return true;
+}
+export function wellFormedBlockTimingAnchorsOf(stored) {
+    const seeded = new Map();
+    const entries = stored;
+    for (const [blockId, timing] of entries) {
+        if (typeof blockId !== "string" || !_isWellFormedTiming(timing)) {
+            continue;
+        }
+        seeded.set(blockId, timing);
+    }
+    return seeded;
+}
+const BLOCK_BOUNDARY_EVENT_TYPES = new Set([
+    EventType.TEXT_MESSAGE_START,
+    EventType.TEXT_MESSAGE_END,
+    EventType.REASONING_START,
+    EventType.REASONING_END,
+    EventType.REASONING_MESSAGE_START,
+    EventType.REASONING_MESSAGE_END,
+    EventType.TOOL_CALL_START,
+    EventType.TOOL_CALL_END,
+    EventType.TOOL_CALL_RESULT,
+]);
+export function blockTimingRecorder(onTimingObserved) {
+    return {
+        onEvent({ event }) {
+            if (!BLOCK_BOUNDARY_EVENT_TYPES.has(event.type)) {
+                return;
+            }
+            const observedAtMs = _timestampOf(event);
+            if (observedAtMs === undefined) {
+                return;
+            }
+            const blockId = _blockIdOf(event);
+            if (blockId !== undefined) {
+                onTimingObserved(blockId, observedAtMs);
+            }
+        },
+    };
+}
+function _timestampOf(event) {
+    if (typeof event !== "object" || event === null) {
+        return undefined;
+    }
+    const { timestamp } = event;
+    if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
+        return undefined;
+    }
+    return timestamp;
+}
+function _blockIdOf(event) {
+    if (typeof event !== "object" || event === null) {
+        return undefined;
+    }
+    const { toolCallId, messageId } = event;
+    if (typeof toolCallId === "string" && toolCallId !== "") {
+        return toolCallId;
+    }
+    if (typeof messageId === "string" && messageId !== "") {
+        return messageId;
+    }
+    return undefined;
+}
+function _isWellFormedTiming(timing) {
+    if (typeof timing !== "object" || timing === null) {
+        return false;
+    }
+    const { startedAtMs, settledAtMs } = timing;
+    const halfIsWellTyped = (half) => half === null || (typeof half === "number" && Number.isFinite(half));
+    return halfIsWellTyped(startedAtMs) && halfIsWellTyped(settledAtMs);
+}

package/dist/core/companion-drawer-flag.d.ts

@@ -0,0 +1,4 @@
+import { type ReadonlyCell } from "./observable-cell.js";
+export declare const companionDrawerOpen: ReadonlyCell<boolean>;
+export declare function openCompanionDrawer(): void;
+export declare function closeCompanionDrawer(): void;

package/dist/core/companion-drawer-flag.js

@@ -0,0 +1,9 @@
+import { ObservableCell } from "./observable-cell.js";
+const _openCell = new ObservableCell(false);
+export const companionDrawerOpen = _openCell;
+export function openCompanionDrawer() {
+    _openCell.set(true);
+}
+export function closeCompanionDrawer() {
+    _openCell.set(false);
+}

package/dist/core/companion-presence.d.ts

@@ -0,0 +1,7 @@
+import type { AssistantSurfacePresence } from "./surface-registry.js";
+export type CompanionChrome = "companion" | "drawer" | "none";
+export interface CompanionChromeInput {
+    surfaces: AssistantSurfacePresence;
+    expanded: boolean;
+}
+export declare function companionChromeOf(input: CompanionChromeInput): CompanionChrome;

package/dist/core/companion-presence.js

@@ -0,0 +1,9 @@
+export function companionChromeOf(input) {
+    if (_yieldsToAnotherSurface(input.surfaces)) {
+        return "none";
+    }
+    return input.expanded ? "drawer" : "companion";
+}
+function _yieldsToAnotherSurface(surfaces) {
+    return surfaces.fullSurfaceMounted || surfaces.transientOpen;
+}

package/dist/core/composer-input-state.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentDraft, ComposerModelPick } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function setModelPickFromStore(store: AssistantConversationStore, pick: ComposerModelPick): void;
+export declare function setComposerDraftFromStore(store: AssistantConversationStore, next: string | ((current: string) => string)): void;
+export declare function setComposerAttachmentsFromStore(store: AssistantConversationStore, next: readonly AttachmentDraft[] | ((current: readonly AttachmentDraft[]) => readonly AttachmentDraft[])): void;
+export declare function resetComposerInput(store: AssistantConversationStore, threadId: string | null): void;
+export declare function noteComposerFocusFromStore(store: AssistantConversationStore, owner: string | null): void;
+export declare function takeComposerCaretReturnFromStore(store: AssistantConversationStore, surface: string): boolean;