@artooi/agents-web-components 0.0.0-stage → 0.1.1

package/dist/core/conversation_store.d.ts

@@ -0,0 +1,195 @@
+import type { Message } from "@ag-ui/core";
+/**
+ * A checkpoint recorded just before a navigating tool reloads the page.
+ *
+ * The reload destroys the in-memory run loop, so the element persists this
+ * marker first; on the next mount it supplies the tool's result and resumes.
+ */
+export interface NavigationCheckpoint {
+    /** The tool-call id whose result must be supplied after the reload. */
+    readonly toolCallId: string;
+}
+/**
+ * Lightweight metadata for one conversation — the thread-drawer row shape, so
+ * the drawer renders without loading message bodies. `title` defaults to a
+ * truncation of the first user message until an explicit rename, `preview` is a
+ * one-line excerpt of the latest message, and `updatedAt` is epoch ms of the
+ * last change, which orders the list.
+ */
+export interface ThreadMeta {
+    readonly threadId: string;
+    readonly title: string;
+    readonly updatedAt: number;
+    readonly preview: string;
+    /**
+     * Whether the thread holds an answer the user has not seen, as a server store
+     * knows it (from a last-read timestamp). Optional: a store that cannot tell
+     * leaves it out, and the element counts only what finishes in this page.
+     */
+    readonly unread?: boolean;
+}
+/**
+ * Client-side persistence seam for the conversation and a pending-navigation
+ * checkpoint, keyed by `thread_id`.
+ *
+ * The default {@link SessionStorageStore} keeps everything per-tab. A host may
+ * inject a server-backed store instead, which is why `loadMessages` and
+ * `listThreads` are async. The checkpoint methods stay synchronous: the marker
+ * is a small local hint a server store can derive from history and no-op.
+ *
+ * Thread enumeration backs the chat-history drawer; deleting a thread reuses
+ * {@link clear}, and "new chat" is {@link newThread} — which leaves the
+ * conversation it moves off of intact, for the drawer to offer back.
+ */
+export interface ClientConversationStore {
+    /** The active conversation id, generated and persisted on first read. */
+    threadId(): string;
+    /**
+     * Start a fresh conversation, make it active, and return its id.
+     *
+     * Existing threads are left where they are: "new chat" adds one, and
+     * {@link clear} is the only method that takes one away.
+     *
+     * Optional: for a store without it, the caller mints the id itself and
+     * hands it to {@link setActiveThread}, which loses only the store's own
+     * record that the thread is new (see {@link isUnsent}).
+     */
+    newThread?(): string;
+    /** Load the persisted message history, or `null` when none exists. */
+    loadMessages(threadId: string): Promise<readonly Message[] | null>;
+    /** Persist the message history (and refresh the thread's drawer metadata). */
+    saveMessages(threadId: string, messages: readonly Message[]): void;
+    /** Load the pending-navigation checkpoint, or `null` when none is set. */
+    loadCheckpoint(threadId: string): NavigationCheckpoint | null;
+    /** Set the pending-navigation checkpoint, or clear it when given `null`. */
+    saveCheckpoint(threadId: string, checkpoint: NavigationCheckpoint | null): void;
+    /** Forget the conversation and checkpoint (a "delete thread" / "new chat"). */
+    clear(threadId: string): void;
+    /** The user's threads as drawer metadata (no message bodies), newest first. */
+    listThreads(): Promise<readonly ThreadMeta[]>;
+    /** Make `threadId` the active conversation (the drawer selecting a row). */
+    setActiveThread(threadId: string): void;
+    /** Set a thread's display title (the drawer renaming a row). */
+    renameThread(threadId: string, title: string): void;
+    /**
+     * Whether `threadId` was minted here and has never been saved — a thread in
+     * which nothing has been sent yet.
+     *
+     * Exists so a server-backed store can skip asking a server for history that
+     * cannot be there: the element mints an id on first mount and immediately tries
+     * to restore it, which answers `404` and logs one in the console on every first
+     * visit. Nothing is wrong, and it looks exactly like something being wrong.
+     *
+     * Optional, and deliberately narrow. A store that cannot tell omits it and the
+     * fetch happens as before, which is also the right answer for a store that
+     * holds nothing locally: "I have no messages for this id" is not the same claim
+     * as "this id is new", and only the store that minted the id can make the
+     * second one. A thread picked from the drawer was never minted here, so it is
+     * still fetched.
+     */
+    isUnsent?(threadId: string): boolean;
+    /**
+     * Record that the user has seen `threadId`'s answers.
+     *
+     * The element calls it when a thread with unseen answers is on screen with
+     * the panel expanded, and when an answer finishes there in view. A server
+     * store maps it to its read endpoint, and should report the thread with
+     * `unread: false` from {@link listThreads} afterwards. It is called inside the
+     * element's expand and thread-change paths, so it must not throw: a store that
+     * writes to a server sends the request without awaiting it and handles its own
+     * failure, the way a failed save is handled.
+     *
+     * Optional: a store without it still has its threads counted and cleared in
+     * the page; nothing is recorded beyond it.
+     */
+    markRead?(threadId: string): void;
+}
+/**
+ * Whether its owner has warned about a refused write yet. Each store and each
+ * storage scope holds one, so an origin-wide, persistent refusal (a full quota
+ * stays full) warns once per owner, not once per persisted turn or, on the
+ * resize path, per keystroke.
+ */
+export interface WriteFailureReport {
+    reported: boolean;
+}
+/**
+ * `sessionStorage.setItem` that survives a store which refuses to write.
+ *
+ * `setItem` throws on an exhausted quota (a long conversation, or one turn
+ * carrying a large tool result) and in privacy modes that deny storage
+ * altogether. Every write here is a *durability* concern — surviving a reload —
+ * and none of them is worth an exception, because of where they are called
+ * from: the element persists the transcript from inside the run loop, so an
+ * unguarded throw escapes as a run error and tells the user the agent failed
+ * when nothing but the browser's storage did. On the cancel path it escapes as
+ * an unhandled rejection instead.
+ *
+ * So a failed write loses the reload, never the conversation on screen, and
+ * says so once per `report`; without one, it says so on every refusal.
+ * Recovery is in the user's hands already: deleting the oversized thread from
+ * the history drawer is a `removeItem`, which frees the quota.
+ */
+export declare function writeStoredItem(key: string, value: string, report?: WriteFailureReport): void;
+/**
+ * Default {@link ClientConversationStore}: per-tab `sessionStorage`.
+ *
+ * Survives full page reloads and same-tab navigation, clears on tab close.
+ * Tracks multiple threads per tab: the active id under one key, message history
+ * and checkpoint namespaced by id, and a small index feeding the drawer with no
+ * server involved.
+ *
+ * An optional `namespace` scopes every key to one element, so two
+ * `<ag-ui-chat>` instances on the same origin keep separate active-thread
+ * pointers and drawer indexes instead of clobbering each other. The default
+ * empty namespace keeps the origin-global keys.
+ */
+export declare class SessionStorageStore implements ClientConversationStore {
+    #private;
+    constructor(namespace?: string);
+    /**
+     * Move every key a store owns out of `from`'s namespace and into `to`'s.
+     *
+     * `<ag-ui-chat>` adopts an element-scoped conversation into a
+     * principal-scoped one the first time a `user-key` arrives, which is a host
+     * naming the user who was already there rather than a handover.
+     *
+     * Only this store's own suffixes move — the element's `collapsed` / `size` /
+     * `theme` keys share the global root and are deliberately left where they
+     * are. A value already present at the destination wins: the destination is
+     * the durable record and the source is the stray this move exists to clear.
+     * A refused write warns once per call.
+     */
+    static adopt(from: string, to: string): void;
+    /**
+     * Forget everything a store holds for `namespace`.
+     *
+     * The logout primitive: `<ag-ui-chat>` calls it when its `user-key` changes,
+     * and a host driving its own store can call it from its own sign-out path.
+     * Deliberately narrow — it removes only keys under this exact namespace whose
+     * suffix parses as one this store writes, so it can never reach another
+     * element's conversation or the host's own `sessionStorage` entries.
+     */
+    static purge(namespace: string): void;
+    threadId(): string;
+    newThread(): string;
+    isUnsent(threadId: string): boolean;
+    loadMessages(threadId: string): Promise<readonly Message[] | null>;
+    saveMessages(threadId: string, messages: readonly Message[]): void;
+    loadCheckpoint(threadId: string): NavigationCheckpoint | null;
+    saveCheckpoint(threadId: string, checkpoint: NavigationCheckpoint | null): void;
+    clear(threadId: string): void;
+    listThreads(): Promise<readonly ThreadMeta[]>;
+    setActiveThread(threadId: string): void;
+    renameThread(threadId: string, title: string): void;
+}
+/**
+ * A thread's title from its first user message, collapsed and truncated, or `""`
+ * when no user message has text.
+ *
+ * A first message that is exactly a skill's `/token` is named rather than
+ * quoted: `skillTitle(token)` when it knows the skill, else the token in words
+ * (`/summarize_draw` reads "Summarize draw").
+ */
+export declare function threadTitleFrom(messages: readonly Message[], skillTitle?: (name: string) => string | undefined): string;
+//# sourceMappingURL=conversation_store.d.ts.map

package/dist/core/conversation_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation_store.d.ts","sourceRoot":"","sources":["../../src/core/conversation_store.ts"],"names":[],"mappings":"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"}

package/dist/core/create_http_agent.d.ts

@@ -0,0 +1,57 @@
+import { type AbstractAgent } from "@ag-ui/client";
+import type { Message } from "@ag-ui/core";
+/** Config for {@link createHttpAgent}. */
+export interface HttpAgentOptions {
+    endpoint: string;
+    headers?: Record<string, string>;
+    /**
+     * Cookie policy for the run request, as `fetch`'s own `credentials` mode.
+     * Unset leaves the browser default (`same-origin`), which sends no cookies
+     * to an agent endpoint on a different origin or subdomain. A
+     * cookie-authenticated cross-origin deployment needs `"include"` here plus a
+     * server answering with `Access-Control-Allow-Credentials: true` and a
+     * concrete origin.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * Live header source, re-read on every request, overlaid on `headers`.
+     * `HttpAgent` bakes static `headers` in at construction and the element
+     * caches the agent for the whole conversation, so rotating credentials (CSRF,
+     * short-lived JWT) must come through here.
+     */
+    getHeaders?: () => Record<string, string>;
+    /** Stable conversation id, so the agent's runs share a thread. */
+    threadId?: string;
+    /** Rehydrated history to seed the agent with (durable conversation). */
+    initialMessages?: readonly Message[];
+    /**
+     * AG-UI shared state to seed the agent with. `@ag-ui/client` sends it as
+     * `RunAgentInput.state` on every run and replaces it in place when the
+     * server streams `STATE_SNAPSHOT` / `STATE_DELTA`.
+     */
+    initialState?: Readonly<Record<string, unknown>>;
+    /**
+     * Origins, besides the document's own, this agent may carry the host's
+     * credentials to.
+     *
+     * Running the agent on another subdomain is a normal deployment and stays
+     * supported, so a cross-origin endpoint is not refused — it is *announced*,
+     * once per origin, on the console. Listing an origin here says the
+     * destination was chosen deliberately and silences the notice for it.
+     *
+     * Entries are compared as serialized origins (`https://agent.example.com`,
+     * scheme and port included), which is what `URL.origin` produces.
+     */
+    trustedOrigins?: readonly string[];
+}
+/**
+ * Build an AG-UI {@link HttpAgent} pointed at `endpoint`.
+ *
+ * The default agent factory for `<ag-ui-chat>`; tests and advanced hosts
+ * override the element's `agentFactory` to inject a different
+ * {@link AbstractAgent}.
+ */
+export declare function createHttpAgent(options: HttpAgentOptions): AbstractAgent;
+/** Signature of the agent factory the element calls to build its agent. */
+export type AgentFactory = (options: HttpAgentOptions) => AbstractAgent;
+//# sourceMappingURL=create_http_agent.d.ts.map

package/dist/core/create_http_agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_http_agent.d.ts","sourceRoot":"","sources":["../../src/core/create_http_agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,eAAe,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,aAAa,CAqCxE;AAED,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,aAAa,CAAC"}

package/dist/core/define_chat.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Register the `<ag-ui-chat>` Custom Element.
+ *
+ * Idempotent: a second call, or one after this package's `AgUiChat` already
+ * holds the tag, is a no-op. If another class holds the tag it throws naming
+ * the tag, because two copies of the element on one page (two bundles, or this
+ * package beside its predecessor) would otherwise run the other one. The class
+ * is not named: in a minified bundle its name is a one-letter identifier.
+ * Registration is an explicit step rather than an import side effect, so
+ * importing the package defines nothing and stays tree-shakeable.
+ */
+export declare function defineChat(): void;
+//# sourceMappingURL=define_chat.d.ts.map

package/dist/core/define_chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_chat.d.ts","sourceRoot":"","sources":["../../src/core/define_chat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAUjC"}

package/dist/core/events/attachments_detail.d.ts

@@ -0,0 +1,9 @@
+import type { AttachmentRef } from "../attachment.js";
+/** `detail` shape of the {@link ATTACHMENT_EVENT} CustomEvent. */
+export interface AttachmentsDetail {
+    /** Durable refs for every file that has finished uploading. */
+    readonly attachments: readonly AttachmentRef[];
+    /** How many files are still uploading; a send now would leave these behind. */
+    readonly pending: number;
+}
+//# sourceMappingURL=attachments_detail.d.ts.map

package/dist/core/events/attachments_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/attachments_detail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B"}

package/dist/core/events/bar_height_detail.d.ts

@@ -0,0 +1,6 @@
+/** `detail` shape of the {@link BAR_HEIGHT_EVENT} CustomEvent. */
+export interface BarHeightDetail {
+    /** The bottom bar's height in CSS px; 0 when no bar is drawn. */
+    readonly height: number;
+}
+//# sourceMappingURL=bar_height_detail.d.ts.map

package/dist/core/events/bar_height_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bar_height_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/bar_height_detail.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB"}

package/dist/core/events/custom_agent_detail.d.ts

@@ -0,0 +1,8 @@
+/** `detail` shape of the {@link CUSTOM_AGENT_EVENT} CustomEvent. */
+export interface CustomAgentDetail {
+    /** The `CUSTOM` event's `name`, verbatim. An open string; never interpreted here. */
+    readonly name: string;
+    /** Its `value`, verbatim and unparsed. `unknown` because the protocol says nothing about it. */
+    readonly value: unknown;
+}
+//# sourceMappingURL=custom_agent_detail.d.ts.map

package/dist/core/events/custom_agent_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom_agent_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/custom_agent_detail.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,qFAAqF;IACrF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB"}

package/dist/core/events/dock_width_detail.d.ts

@@ -0,0 +1,8 @@
+/** `detail` shape of the {@link DOCK_WIDTH_EVENT} CustomEvent. */
+export interface DockWidthDetail {
+    /** The CSS px the docked panel covers at rest; 0 when it covers none of the page. */
+    readonly width: number;
+    /** The edge the panel docks against. */
+    readonly side: "left" | "right";
+}
+//# sourceMappingURL=dock_width_detail.d.ts.map

package/dist/core/events/dock_width_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dock_width_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/dock_width_detail.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC"}

package/dist/core/events/feedback_detail.d.ts

@@ -0,0 +1,28 @@
+/** {@link FEEDBACK_EVENT} detail: what was rated, and how. */
+export interface FeedbackDetail {
+    /** The rated message's text, as rendered. */
+    readonly content: string;
+    readonly rating: "up" | "down";
+    /**
+     * The AG-UI id of the rated assistant message: the id it streamed under, or
+     * the stored message's `id` when it was restored from history.
+     *
+     * What a host stores a rating against. `content` cannot be: two answers can
+     * read the same, and the text says nothing about which stored message it
+     * was. A restored message carries whatever id its store returns: the
+     * built-in browser store keeps the streamed ids, and a server-backed one
+     * keeps them only where the server persists the ids it streamed.
+     */
+    readonly messageId: string;
+    /** The conversation the message belongs to: the element's thread when it was drawn. */
+    readonly threadId: string;
+    /**
+     * The run that streamed the message, as its `RUN_STARTED` named it.
+     *
+     * Present only on a message that arrived live. A restored one has none to
+     * give -- an AG-UI message carries no run id -- so the key is absent there
+     * rather than holding a value that only looks like one.
+     */
+    readonly runId?: string;
+}
+//# sourceMappingURL=feedback_detail.d.ts.map

package/dist/core/events/feedback_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/feedback_detail.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/core/events/invalidate_detail.d.ts

@@ -0,0 +1,16 @@
+/** `detail` shape of the {@link INVALIDATE_EVENT} CustomEvent. */
+export interface InvalidateDetail {
+    /**
+     * The resources that moved, as the server named them.
+     *
+     * **Opaque strings, and matching is exact.** `orders/42` does not imply
+     * `orders` -- a prefix rule would be this component guessing at a scheme it
+     * does not own, and `orders/1` would match `orders/11`. A server that wants
+     * the collection refreshed names it. Your own matching may be hierarchical,
+     * because in your vocabulary the scheme is known.
+     */
+    readonly keys: readonly string[];
+    /** What caused the write -- usually the tool's name. `null` when unstated. */
+    readonly reason: string | null;
+}
+//# sourceMappingURL=invalidate_detail.d.ts.map

package/dist/core/events/invalidate_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidate_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/invalidate_detail.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC"}

package/dist/core/events/maximize_detail.d.ts

@@ -0,0 +1,5 @@
+/** `detail` shape of the {@link MAXIMIZE_EVENT} CustomEvent. */
+export interface MaximizeDetail {
+    readonly maximized: boolean;
+}
+//# sourceMappingURL=maximize_detail.d.ts.map

package/dist/core/events/maximize_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maximize_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/maximize_detail.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B"}

package/dist/core/events/run_finished_detail.d.ts

@@ -0,0 +1,36 @@
+import type { ToolRun } from "./tool_run.js";
+/** `detail` shape of the {@link RUN_FINISHED_EVENT} CustomEvent. */
+export interface RunFinishedDetail {
+    /**
+     * The thread the run belonged to, fixed when its client was built. Not always
+     * the thread on screen: a run stopped by a new chat or a thread switch still
+     * reports once its request closes, and by then another thread is.
+     */
+    readonly threadId: string;
+    /** In settle order. Empty when the interaction called no tools. */
+    readonly tools: readonly ToolRun[];
+    /**
+     * Every key announced during the interaction, de-duplicated, first-seen order.
+     *
+     * **This is the field that makes adoption one line** for a host already
+     * listening here, and the `else` is the whole compatibility story:
+     *
+     * ```js
+     * if (detail.invalidated.length > 0) refetchOnly(detail.invalidated);
+     * else if (detail.tools.some((t) => t.side === "server")) refetchEverything();
+     * ```
+     *
+     * Empty against a server that announces nothing, so an old server and a new
+     * client fall through to the coarse refetch that shipped before either.
+     */
+    readonly invalidated: readonly string[];
+    /**
+     * How the interaction ended: `"completed"` when it ran to its end, `"stopped"`
+     * when Stop, a new chat or a thread switch cut it off, `"failed"` when the
+     * agent reported an error. Reported for a run the conversation has left
+     * behind too, so a host can tell a cancelled run's late event from the live
+     * run's own. A host should ignore a value it does not know.
+     */
+    readonly outcome: "completed" | "stopped" | "failed";
+}
+//# sourceMappingURL=run_finished_detail.d.ts.map

package/dist/core/events/run_finished_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_finished_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/run_finished_detail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;CACtD"}

package/dist/core/events/state_detail.d.ts

@@ -0,0 +1,5 @@
+/** `detail` shape of the {@link STATE_EVENT} CustomEvent. */
+export interface StateDetail {
+    readonly state: Readonly<Record<string, unknown>>;
+}
+//# sourceMappingURL=state_detail.d.ts.map

package/dist/core/events/state_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/state_detail.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD"}

package/dist/core/events/submit_detail.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentRef } from "../attachment.js";
+/** `detail` shape of the {@link SUBMIT_EVENT} CustomEvent. */
+export interface SubmitDetail {
+    readonly content: string;
+    /** Durable refs for the files attached to this message (empty when none). */
+    readonly attachments: readonly AttachmentRef[];
+}
+//# sourceMappingURL=submit_detail.d.ts.map

package/dist/core/events/submit_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/submit_detail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;CAChD"}

package/dist/core/events/thread_detail.d.ts

@@ -0,0 +1,27 @@
+/** `detail` shape of the {@link THREAD_EVENT} CustomEvent. */
+export interface ThreadDetail {
+    /** The thread now on screen. */
+    readonly threadId: string;
+    /**
+     * The thread on screen before the change: the one the previous event
+     * reported, and `null` before the first, as at the restore when the element
+     * first connects. Equal to `threadId` when the same thread was restored
+     * again (`reload()`, the element connecting again).
+     */
+    readonly previousThreadId: string | null;
+    /**
+     * What changed it:
+     *
+     * - `new`: `newChat()` or the built-in New chat button.
+     * - `switch`: `switchThread()` or a row picked in the conversation list.
+     * - `delete`: the active thread was deleted, and a fresh one took its place.
+     * - `restore`: the stored thread was replayed, on connect or by `reload()`.
+     * - `rescope`: a `user-key` change handed the element to another principal,
+     *   live or while it was out of the document.
+     *
+     * A closed set today; a host should ignore a reason it does not know, so a
+     * later one can be added without breaking it.
+     */
+    readonly reason: "new" | "switch" | "delete" | "restore" | "rescope";
+}
+//# sourceMappingURL=thread_detail.d.ts.map

package/dist/core/events/thread_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/thread_detail.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;CACtE"}

package/dist/core/events/thread_title_detail.d.ts

@@ -0,0 +1,8 @@
+/** `detail` shape of the {@link THREAD_TITLE_EVENT} CustomEvent. */
+export interface ThreadTitleDetail {
+    /** The thread on screen. */
+    readonly threadId: string;
+    /** Its title, as `threadTitle` reads it now; `""` for a thread with nothing sent. */
+    readonly title: string;
+}
+//# sourceMappingURL=thread_title_detail.d.ts.map

package/dist/core/events/thread_title_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread_title_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/thread_title_detail.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB"}

package/dist/core/events/toggle_detail.d.ts

@@ -0,0 +1,5 @@
+/** `detail` shape of the {@link TOGGLE_EVENT} CustomEvent. */
+export interface ToggleDetail {
+    readonly collapsed: boolean;
+}
+//# sourceMappingURL=toggle_detail.d.ts.map

package/dist/core/events/toggle_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/toggle_detail.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B"}

package/dist/core/events/tool_run.d.ts

@@ -0,0 +1,11 @@
+/** One tool that ran during an interaction, as {@link RunFinishedDetail} lists it. */
+export interface ToolRun {
+    readonly name: string;
+    /**
+     * Where it executed. `"server"` is the one a data-rendering host cares about:
+     * a `"client"` tool ran in the host's own handler, so the host already knows
+     * whatever it did.
+     */
+    readonly side: "server" | "client";
+}
+//# sourceMappingURL=tool_run.d.ts.map

package/dist/core/events/tool_run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_run.d.ts","sourceRoot":"","sources":["../../../src/core/events/tool_run.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACpC"}

package/dist/core/events/unread_detail.d.ts

@@ -0,0 +1,11 @@
+/** `detail` shape of the {@link UNREAD_EVENT} CustomEvent. */
+export interface UnreadDetail {
+    /** Unseen answers across every thread: what the launcher badge shows. */
+    readonly unread: number;
+    /**
+     * The threads whose unseen answers this change marked or cleared; empty when
+     * none did (a collapse toggle still reports the total).
+     */
+    readonly threadIds: readonly string[];
+}
+//# sourceMappingURL=unread_detail.d.ts.map

package/dist/core/events/unread_detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unread_detail.d.ts","sourceRoot":"","sources":["../../../src/core/events/unread_detail.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC"}

package/dist/core/message_role.d.ts

@@ -0,0 +1,4 @@
+import type { MESSAGE_ROLE } from "../constants.js";
+/** The role a rendered chat message takes. */
+export type MessageRole = (typeof MESSAGE_ROLE)[keyof typeof MESSAGE_ROLE];
+//# sourceMappingURL=message_role.d.ts.map

package/dist/core/message_role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_role.d.ts","sourceRoot":"","sources":["../../src/core/message_role.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,8CAA8C;AAC9C,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/core/read_flag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read an opt-in flag attribute on `element` the way HTML reads a boolean
+ * attribute.
+ *
+ * Present means on: bare (`data-prompt-chips`), empty (`=""`), or any value
+ * except the literal `"false"`. Comparing against `"true"` instead would make
+ * the bare spelling every native boolean attribute uses silently disable the
+ * feature it names. `="false"` still turns it off.
+ */
+export declare function readFlag(element: Element, name: string): boolean;
+//# sourceMappingURL=read_flag.d.ts.map

package/dist/core/read_flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_flag.d.ts","sourceRoot":"","sources":["../../src/core/read_flag.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhE"}

package/dist/core/read_json_attribute.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parse a JSON-valued attribute on `element`, saying so when it will not parse.
+ *
+ * `null` for an absent attribute, and `null` again for one that is not JSON --
+ * but not quietly the second time. Quoting JSON inside an HTML attribute is
+ * fiddly, and the result of getting it wrong is indistinguishable from the
+ * feature being switched off: no chips appear, or the strings stay English,
+ * with nothing anywhere saying why. That is the same failure `data-paste-attach`
+ * already reports for a value it cannot read.
+ *
+ * Console only. A page author's typo is not the reader's business, nothing the
+ * reader did was refused, and the degraded widget is still perfectly usable.
+ */
+export declare function readJsonAttribute(element: Element, name: string): unknown;
+//# sourceMappingURL=read_json_attribute.d.ts.map

package/dist/core/read_json_attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_json_attribute.d.ts","sourceRoot":"","sources":["../../src/core/read_json_attribute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBzE"}

package/dist/core/read_max_tool_rounds.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The tool-round budget from `element`'s `data-max-tool-rounds`, for one send.
+ *
+ * Anything unparseable becomes `NaN`, which {@link AgUiClient} rejects along
+ * with a bound below one -- so the two ways of setting this are validated in
+ * one place rather than agreeing by coincidence.
+ */
+export declare function readMaxToolRounds(element: Element): number;
+//# sourceMappingURL=read_max_tool_rounds.d.ts.map

package/dist/core/read_max_tool_rounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_max_tool_rounds.d.ts","sourceRoot":"","sources":["../../src/core/read_max_tool_rounds.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAG1D"}