@teaflask/assistant 0.3.0 → 0.7.0

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

@@ -1,12 +1,4 @@
 import { ObservableCell } from "./observable-cell.js";
-// The companion drawer's open flag, as page-level state rather than a
-// component's: the host may remount the whole assistant tree between
-// routes (the dashboard's route shells differ), and the drawer must land
-// on the destination exactly as the last writer left it. Three writers:
-// the mark and the drawer's own controls, the navigate handler (a tool
-// navigation opens it), and a full surface taking the floor (closes it).
-// Module-scoped like the surface registry — the handler runs outside any
-// React tree — and in memory only: a full page load starts closed.
 const _openCell = new ObservableCell(false);
 export const companionDrawerOpen = _openCell;
 export function openCompanionDrawer() {
@@ -15,4 +7,3 @@ export function openCompanionDrawer() {
 export function closeCompanionDrawer() {
     _openCell.set(false);
 }
-//# sourceMappingURL=companion-drawer-flag.js.map

package/dist/core/companion-presence.js

@@ -4,13 +4,6 @@ export function companionChromeOf(input) {
     }
     return input.expanded ? "drawer" : "companion";
 }
-/** A full-surface chrome anywhere hides everything: that surface is the
- *  assistant now. The open palette hides the whole cluster too, drawer
- *  included: the widget keeps its expanded flag, so the drawer returns the
- *  moment the palette closes — but while the palette holds the transcript
- *  lease the drawer would render as a hollow shell behind the modal, and
- *  two gutted twins of one surface read as broken. */
 function _yieldsToAnotherSurface(surfaces) {
     return surfaces.fullSurfaceMounted || surfaces.transientOpen;
 }
-//# sourceMappingURL=companion-presence.js.map

package/dist/core/composer-attachments.js

@@ -0,0 +1,82 @@
+import { ASSISTANT_MAX_ATTACHMENTS } from "../contract/threads.js";
+import { humanFileSize } from "../components/human-file-size.js";
+import { capSlotsSpentBy, mintAttachmentDraftId, pickCapOf, } from "./composer-policy.js";
+const ATTACHMENTS_UNAVAILABLE_SENTENCE = "Attachments aren't available right now.";
+const UPLOAD_FAILED_SENTENCE = "The upload failed.";
+export function attachmentRoomOf(policy) {
+    return Math.min(policy.max_per_message, ASSISTANT_MAX_ATTACHMENTS);
+}
+function attachmentTooLargeSentence(cap) {
+    return `Too large — the limit for ${cap.label} is ${humanFileSize(cap.bytes)}.`;
+}
+function tooManyAttachmentsSentence(room) {
+    return `Too many files — the limit is ${String(room)} per message.`;
+}
+export async function addComposerFilesFromStore(store, files) {
+    const picked = [...files];
+    if (picked.length === 0) {
+        return;
+    }
+    const resets = store._composerInputResets;
+    const policy = store.deps.attachmentPolicy.get() ??
+        (await store.deps.ensureAttachmentPolicy());
+    if (store._composerInputResets !== resets) {
+        return;
+    }
+    if (policy === null) {
+        _appendDrafts(store, picked.map((file) => _failedDraft(_uploadingDraftFor(file), ATTACHMENTS_UNAVAILABLE_SENTENCE)));
+        return;
+    }
+    const room = attachmentRoomOf(policy);
+    let taken = capSlotsSpentBy(store._composerInput.get().attachments);
+    const settling = [];
+    for (const file of picked) {
+        const entry = _uploadingDraftFor(file);
+        if (taken >= room) {
+            _appendDrafts(store, [
+                _failedDraft(entry, tooManyAttachmentsSentence(room)),
+            ]);
+            continue;
+        }
+        const cap = pickCapOf(file, policy.max_bytes_by_kind);
+        if (file.size > cap.bytes) {
+            _appendDrafts(store, [
+                _failedDraft(entry, attachmentTooLargeSentence(cap)),
+            ]);
+            continue;
+        }
+        taken += 1;
+        _appendDrafts(store, [entry]);
+        settling.push(_uploadDraft(store, file, entry.localId));
+    }
+    await Promise.all(settling);
+}
+function _uploadingDraftFor(file) {
+    return {
+        localId: mintAttachmentDraftId(),
+        filename: file.name !== "" ? file.name : "attachment",
+        byteSize: file.size,
+        status: "uploading",
+    };
+}
+function _failedDraft(entry, error) {
+    return { ...entry, status: "failed", error };
+}
+function _appendDrafts(store, drafts) {
+    store.setComposerAttachments((current) => [...current, ...drafts]);
+}
+async function _uploadDraft(store, file, localId) {
+    try {
+        const settled = await store.uploadAttachment(file);
+        _settleDraft(store, localId, { status: "ready", attachment: settled });
+    }
+    catch (error) {
+        _settleDraft(store, localId, {
+            status: "failed",
+            error: error instanceof Error ? error.message : UPLOAD_FAILED_SENTENCE,
+        });
+    }
+}
+function _settleDraft(store, localId, patch) {
+    store.setComposerAttachments((current) => current.map((item) => item.localId === localId ? { ...item, ...patch } : item));
+}

package/dist/core/composer-input-state.js

@@ -1,18 +1,9 @@
-// The composer's input plane: the model pick, the unsaved draft and its
-// staged attachments, the focus/caret bookkeeping, and the reset that
-// re-scopes them — the store-side half of the composer's contract.
 import { publishStore } from "./conversation-publish.js";
 export function setModelPickFromStore(store, pick) {
     store._modelPick = pick;
     store._modelPickDirty = true;
     publishStore(store);
 }
-// Value-or-updater on purpose (the useState contract): the upload
-// continuations and the send-refusal restore are read-modify-write over
-// truth that may have moved, and as the STORE's stable arrows they stay
-// correct across any composer remount. They write the input cell directly,
-// never publishStore: a keystroke moves no conversation-plane state. Only
-// adoption, abandon and a landed send move the scope; it rides through here.
 export function setComposerDraftFromStore(store, next) {
     const current = store._composerInput.get();
     store._composerInput.set({
@@ -27,15 +18,9 @@ export function setComposerAttachmentsFromStore(store, next) {
         attachments: typeof next === "function" ? next(current.attachments) : next,
     });
 }
-// Clearing is (re)scoping: every reset names the conversation-context the
-// fresh, empty input belongs to — the identity the send-refusal guard
-// compares against. Both arms set UNCONDITIONALLY: a conversation-less
-// reset MINTS a fresh token even over an empty input (a null hole here let
-// an abandon no-op and leave the old scope alive for the refusal restore).
-// A caret owed to the departed conversation dies with it; the DOM-plane
-// focus record is NOT touched — it tracks the element, not the conversation.
 export function resetComposerInput(store, threadId) {
     store._composerCaretReturnPending = null;
+    store._composerInputResets += 1;
     store._composerInput.set({
         scope: threadId !== null
             ? `t:${threadId}`
@@ -47,11 +32,6 @@ export function resetComposerInput(store, threadId) {
 export function noteComposerFocusFromStore(store, owner) {
     store._composerFocusOwned = owner;
 }
-// Take-semantics scoped to the OWNER: every keyed transcript remounts on
-// one nonce bump and every fresh composer takes at mount, in tree order —
-// an unscoped take let a bystander surface consume the one-shot without
-// using it. Only the owner's take consumes; the owner then delivers or
-// forfeits its return in the same breath, which is the right lifetime.
 export function takeComposerCaretReturnFromStore(store, surface) {
     if (store._composerCaretReturnPending !== surface) {
         return false;
@@ -59,4 +39,3 @@ export function takeComposerCaretReturnFromStore(store, surface) {
     store._composerCaretReturnPending = null;
     return true;
 }
-//# sourceMappingURL=composer-input-state.js.map

package/dist/core/composer-policy.d.ts

@@ -1,12 +1,32 @@
 import { type ServingAttachment } from "../contract/threads.js";
 import type { AttachmentKind } from "../generated/models/index.js";
 export declare const CHARACTER_COUNT_VISIBLE_FROM: number;
+/** One file staged in the composer for the next message. */
 export interface AttachmentDraft<A = ServingAttachment> {
+    /**
+     * An id for this file that is unique within the page, for React keys and
+     * for updating or removing it.
+     */
     localId: number;
+    /** The file's name as shown to the visitor. */
     filename: string;
+    /** The file's size in bytes. */
     byteSize: number;
+    /**
+     * uploading while the file is being uploaded, ready once it can be sent,
+     * failed if it was rejected or the upload failed. The package composer
+     * won't send while any file is uploading or failed.
+     */
     status: "uploading" | "ready" | "failed";
+    /**
+     * The uploaded attachment, set once status is ready; pass its id to
+     * sendMessage.
+     */
     attachment?: A;
+    /**
+     * Why the file failed, as a sentence for the visitor; set only when status
+     * is failed.
+     */
     error?: string;
 }
 export declare function mintAttachmentDraftId(): number;
@@ -26,18 +46,6 @@ export interface ComposerKeyEvent {
     preventDefault: () => void;
     stopPropagation: () => void;
 }
-/**
- * The composer's two keyboard verbs, bound as composerKeys on the textarea
- * and stopOnEscape on the stop button. Enter submits (Shift+Enter is a
- * newline). Escape while the assistant is answering is the stop shortcut,
- * claimed ONLY when stopTurn can actually act: the two windows
- * where it no-ops pass through unclaimed — the message POST (pendingSend,
- * the store's truth, not a component's sending mirror; no turn exists to
- * stop yet) and the "Stopping…" beat itself (the re-entry guard refuses a
- * second stop) — because a swallowed no-op Escape is how a palette,
- * drawer or pane gets wedged. Bound on the textarea and the stop button,
- * the two focus homes of a busy composer.
- */
 export declare function composerKeyHandlersOf(input: {
     busy: boolean;
     pendingSend: boolean;
@@ -48,4 +56,3 @@ export declare function composerKeyHandlersOf(input: {
     stopOnEscape: (event: ComposerKeyEvent) => void;
     composerKeys: (event: ComposerKeyEvent) => void;
 };
-//# sourceMappingURL=composer-policy.d.ts.map

package/dist/core/composer-policy.js

@@ -1,37 +1,15 @@
-// The composer's pure policy leaf, React-free and transport-free: the
-// members both composers — the package's slab and the dashboard
-// playground's — apply to a draft before anything is sent. One home
-// so the fork ledger has nothing to pin: the per-message
-// bounds are felt while typing, the cap slots count only drafts that
-// could still ride, the pick-time size check speaks the served kind's
-// cap, and Escape/Enter mean the same thing in every composer.
 import { ASSISTANT_MESSAGE_MAX_CHARS, } from "../contract/threads.js";
-// Show the countdown only once it starts to matter.
 export const CHARACTER_COUNT_VISIBLE_FROM = ASSISTANT_MESSAGE_MAX_CHARS - 400;
-// Chip ids are minted here, module-scoped, so they survive any composer
-// remount and never collide across the composers one page may mount.
 let nextDraftId = 1;
 export function mintAttachmentDraftId() {
     return nextDraftId++;
 }
-// The one reading of a draft's failed state: a refused pick or a failed
-// upload. Every surface asks this rather than comparing the word — the
-// dashboard's collapse-layer law keeps status literals out of its
-// components, and one predicate keeps the two composers agreeing on
-// what "failed" means.
 export function attachmentDraftFailed(item) {
     return item.status === "failed";
 }
-// What counts against the per-message cap: only drafts that could still
-// ride the message. A failed chip never sends, so it never spends a
-// slot — it holds visible ground until removed, nothing more.
 export function capSlotsSpentBy(attachments) {
     return attachments.filter((item) => !attachmentDraftFailed(item)).length;
 }
-// The pick-time size cap: the kind's own ceiling when the browser's
-// MIME type names one confidently and the caps serve that kind, else the
-// widest cap served — the pre-check must never be stricter than the
-// server's sniffed truth.
 export function pickCapOf(file, caps) {
     const type = file.type;
     if (type.startsWith("image/") && caps.image !== undefined) {
@@ -52,18 +30,6 @@ export function pickCapOf(file, caps) {
         label: "a file",
     };
 }
-/**
- * The composer's two keyboard verbs, bound as composerKeys on the textarea
- * and stopOnEscape on the stop button. Enter submits (Shift+Enter is a
- * newline). Escape while the assistant is answering is the stop shortcut,
- * claimed ONLY when stopTurn can actually act: the two windows
- * where it no-ops pass through unclaimed — the message POST (pendingSend,
- * the store's truth, not a component's sending mirror; no turn exists to
- * stop yet) and the "Stopping…" beat itself (the re-entry guard refuses a
- * second stop) — because a swallowed no-op Escape is how a palette,
- * drawer or pane gets wedged. Bound on the textarea and the stop button,
- * the two focus homes of a busy composer.
- */
 export function composerKeyHandlersOf(input) {
     const { busy, pendingSend, stopping, stopTurn, submit } = input;
     function submitOnEnter(event) {
@@ -88,4 +54,3 @@ export function composerKeyHandlersOf(input) {
         },
     };
 }
-//# sourceMappingURL=composer-policy.js.map

package/dist/core/connect-gate.d.ts

@@ -1,8 +1,4 @@
 import type { ConnectProjectionResponse, SubscriptionProvider } from "../generated/models/index.js";
-/** Why a connect gate is asking: the free preview ran out (a first
- *  connect) or a connected plan's credential died (a reconnect). The
- *  contract grows reasons additively; unknown values read as
- *  auth_bounced — the conservative ask. */
 type ConnectGateReason = "taster_exhausted" | "auth_bounced";
 export type ConversationGate = {
     kind: "none";
@@ -19,17 +15,7 @@ export type ConversationGate = {
     kind: "verifying";
 };
 export declare const NO_GATE: ConversationGate;
-/** Whether two gates say the same thing. The projection mints a fresh
- *  object every read, so the registry dedupes on substance before
- *  writing its cell — an unchanged gate must not notify (each notify
- *  re-renders every gate consumer, and a re-render storm under a
- *  4s re-read chain is how a bounded poll turns unbounded). */
 export declare function gatesEqual(a: ConversationGate, b: ConversationGate): boolean;
-/** The projection's gate, client-shaped. An unknown gate value reads as
- *  none — the contract's growth rule; the send door stays the truth. */
 export declare function gateOfProjection(connect: ConnectProjectionResponse | undefined): ConversationGate;
-/** A send refusal's gate, or null when the refusal is not a gate (a rate
- *  limit, a busy thread — the banner's story, not the composer's). */
 export declare function gateOfRefusal(error: unknown): ConversationGate | null;
 export {};
-//# sourceMappingURL=connect-gate.d.ts.map

package/dist/core/connect-gate.js

@@ -1,24 +1,10 @@
-// The conversation gate: what stands between this visitor
-// and their next send, as one client-side shape with two producers — the
-// assistant-config read's pre-flight projection (the gate is known before
-// anyone types) and a send refusal (the race window where the projection
-// was stale). ConversationView renders it in the composer's place; the
-// provider chip and the gate card are its readers.
 import { ServingApiError } from "../transport/serving-error.js";
 export const NO_GATE = { kind: "none" };
-/** Whether two gates say the same thing. The projection mints a fresh
- *  object every read, so the registry dedupes on substance before
- *  writing its cell — an unchanged gate must not notify (each notify
- *  re-renders every gate consumer, and a re-render storm under a
- *  4s re-read chain is how a bounded poll turns unbounded). */
 export function gatesEqual(a, b) {
     if (a.kind !== b.kind) {
         return false;
     }
     if (a.kind === "connect" && b.kind === "connect") {
-        // Joined, not compared elementwise: the provider union has one
-        // member today, and TS narrows an element comparison to
-        // always-true (the vocabulary grows additively).
         return (a.reason === b.reason && a.providers.join(" ") === b.providers.join(" "));
     }
     if (a.kind === "wait" && b.kind === "wait") {
@@ -26,8 +12,6 @@ export function gatesEqual(a, b) {
     }
     return true;
 }
-/** The projection's gate, client-shaped. An unknown gate value reads as
- *  none — the contract's growth rule; the send door stays the truth. */
 export function gateOfProjection(connect) {
     if (connect === undefined) {
         return NO_GATE;
@@ -49,8 +33,6 @@ export function gateOfProjection(connect) {
             return NO_GATE;
     }
 }
-/** A send refusal's gate, or null when the refusal is not a gate (a rate
- *  limit, a busy thread — the banner's story, not the composer's). */
 export function gateOfRefusal(error) {
     if (!(error instanceof ServingApiError)) {
         return null;
@@ -77,9 +59,6 @@ export function gateOfRefusal(error) {
     }
     return null;
 }
-/** The refusal envelope's structured half, read leniently: details is
- *  `unknown` on the wire by design, and a malformed shape must degrade
- *  to an empty ask, never throw under an error handler. */
 function _connectDetailsOf(error) {
     const details = error.details;
     if (typeof details !== "object" || details === null) {
@@ -104,4 +83,3 @@ function _retryAtMsOf(connect) {
     }
     return Date.now() + connect.retry_after_seconds * 1000;
 }
-//# sourceMappingURL=connect-gate.js.map

package/dist/core/connection-driver.js

@@ -1,22 +1,7 @@
-// The connection driver: the store is the ONLY socket driver — the truth
-// table decides when one is held, an epoch connects ONCE, a background
-// attach remints the epoch, and the stream-end verdict tells a designed
-// stop from an attach or a death. Record: docs/connection-lifecycle.md.
 import { settlesFor } from "./conversation-refresh.js";
 import { publishStore, scheduleConnectionSync, } from "./conversation-publish.js";
-// The stream-end refresh's bound: how long _connectionEnded may
-// hold the connect gate for REST's verdict. This transport aborts nothing,
-// so the bound — never the GET — releases the gate. Equal to the
-// delivery-claim window on purpose; its own constant so it stays retunable.
 const CONNECTION_ENDED_REFRESH_BOUND_MS = 8_000;
-// The hard bound on store-initiated reconnects: an unattended reconnect
-// loop on a public embed is the one failure mode this feature must not
-// have. No-progress automatic reconnects stop here and surface
-// stream-trouble; a human retry, a mount, or a new turn resets the count.
 const MAX_AUTOMATIC_RECONNECTS = 5;
-// The connection truth table (docs/connection-lifecycle.md): a mounted
-// surface connects ONCE per epoch; headless, only queued|working holds a
-// socket — parked keeps the epoch armed but NO socket.
 export function turnHoldsAStream(store) {
     const status = store._newestTurn?.status;
     return status === "queued" || status === "working";
@@ -50,30 +35,16 @@ export function syncConnection(store) {
         .catch(() => undefined);
 }
 function _remintForBackgroundAttach(store) {
-    // A wanted connect on a USED epoch (a background-initiated turn
-    // landed after this epoch's stream closed). Connect-ONCE is the agent's
-    // frozen-cursor law, so remint on the BACKGROUND nonce — never
-    // _reconnectNonce, which would remount the visitor's subtree. Only
-    // _streamInterrupted resets here; the rest belong to other lifecycles.
     store._streamInterrupted = false;
     store._backgroundAttachNonce += 1;
     publishStore(store);
 }
-// The stream ended. REST is the authority on what that meant:
-// park/settle are designed stops (no reconnect — the human's POST
-// begins the next epoch); a turn the workflow still owns means the
-// connection died under us, and the store reconnects on a fresh epoch
-// under the automatic budget.
 async function _connectionEnded(store, epoch, turnBefore) {
     let refreshSettled = false;
     try {
         if (_connectionDecisionMoot(store, epoch)) {
             return;
         }
-        // Held through the refresh so its publishes cannot race a second
-        // connect — but BOUNDED BY THE TIMER, NEVER THE GET: the
-        // gate's release must not depend on a network promise settling; any
-        // settled rejection releases it through the finally below.
         refreshSettled = await Promise.race([
             store.refreshConversation().then(() => true),
             settlesFor(CONNECTION_ENDED_REFRESH_BOUND_MS).then(() => false),
@@ -81,8 +52,6 @@ async function _connectionEnded(store, epoch, turnBefore) {
     }
     finally {
         store._connectionRunning = false;
-        // A mooted decision (an epoch retired mid-connection) still owes the
-        // fresh epoch its connect decision, and nothing else re-triggers it.
         if (_connectionDecisionMoot(store, epoch)) {
             scheduleConnectionSync(store);
         }
@@ -97,22 +66,14 @@ async function _connectionEnded(store, epoch, turnBefore) {
     _judgeStreamEnd(store, turnBefore);
 }
 function _judgeBoundedOut(store) {
-    // BOUNDED OUT: REST never confirmed _newestTurn, so the arms
-    // below must not judge on it. Charge the automatic budget (the only
-    // thing bounding a remint loop on wedged REST) and reschedule the sync.
     store._automaticReconnects += 1;
     if (store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
-        // EXHAUSTION MUST BE LOUD HERE TOO: with REST wedged, retryStream —
-        // reachable only through the banner — is the sole in-page reset, so a
-        // quiet return here would be a permanent, reload-only dead end.
         store._streamInterrupted = true;
         publishStore(store);
         return;
     }
     scheduleConnectionSync(store);
 }
-// The refresh landed: judge what the close meant on REST-confirmed truth
-// — a designed stop, a background attach, or a death under a live turn.
 function _judgeStreamEnd(store, turnBefore) {
     if (!turnHoldsAStream(store)) {
         store._automaticReconnects = 0;
@@ -120,47 +81,26 @@ function _judgeStreamEnd(store, turnBefore) {
         return;
     }
     if (store._newestTurn?.id !== turnBefore?.id) {
-        // THE ATTACH/DEATH DISCRIMINATOR: a changed newest-turn id is
-        // an ATTACH, not a death — turn ids are immutable, so a same-id live
-        // turn IS the watched one dying. Ride the background nonce (no
-        // remount), never the reconnect bump; the budget zeroed on adoption.
         publishStore(store);
         return;
     }
     _reconnectAfterDeath(store, turnBefore);
 }
-// The same turn is still live after the close: the connection died under
-// us. Count it against the automatic budget and reconnect by remount.
 function _reconnectAfterDeath(store, turnBefore) {
     const progressed = store._newestTurn?.updated_at !== turnBefore?.updated_at ||
         store._newestTurn?.status !== turnBefore?.status;
     store._automaticReconnects = progressed ? 1 : store._automaticReconnects + 1;
     if (store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
-        // The bound, not just a stop condition: surface stream-trouble and
-        // wait for a human (retry, mount) or a new turn to reset it.
         store._streamInterrupted = true;
         publishStore(store);
         return;
     }
-    // THE DEATH ARM'S REMOUNT IS DELIBERATE: the bump moves the Transcript
-    // key (thread.id#reconnectNonce), resetting the subtree's UI state on a
-    // fresh epoch. It must NEVER eat unsaved input: the draft lives
-    // on the store's _composerInput cell, above the key; no reconnect clears it.
     store._reconnectNonce += 1;
-    // THE CARET: the remount tears down a focused textarea with no blur, so
-    // hand the caret back AT THE REMOUNT (the box stays live), and ONLY when
-    // the composer demonstrably owned focus. ORDERING: read synchronously
-    // BEFORE the publishStore() below, whose remount invalidates the record.
     if (store._composerFocusOwned !== null) {
         store._composerCaretReturnPending = store._composerFocusOwned;
     }
     publishStore(store);
 }
-// Disposal or an epoch swap takes the decision out of this connect's
-// hands — read fresh on every consult because both can move during the
-// awaits above. (Surface presence no longer moots anything: mounted or
-// not, the store is the driver.)
 function _connectionDecisionMoot(store, epoch) {
     return store._disposed || store._epoch !== epoch;
 }
-//# sourceMappingURL=connection-driver.js.map