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

package/dist/ui/excerpts/transcript_quote_offer.d.ts

@@ -0,0 +1,57 @@
+import type { UiStrings } from "../ui_strings.js";
+/** What the quote offer needs from the element that owns it. */
+export interface TranscriptQuoteHost {
+    /** The custom element: its opt-out attribute, and what a page offer excludes. */
+    readonly element: HTMLElement;
+    /** The shadow root a transcript selection is read through. */
+    readonly root: ShadowRoot;
+    /** The transcript, whose selections are offered. */
+    readonly messages: HTMLElement;
+    /** The transcript's positioning box, which the offer floats inside. */
+    readonly messagesWrap: HTMLElement;
+    /** The composer a quotation is written into. */
+    readonly input: HTMLTextAreaElement;
+    /** The resolved string table. */
+    readonly strings: () => UiStrings;
+    /** Resize the composer to what it now holds. */
+    readonly autoGrow: () => void;
+    /** The element's public `quote`, so a host that replaced it is the one called. */
+    readonly quote: (text: string) => void;
+}
+/**
+ * Quoting a selection into the composer: the offer floated beside a selection
+ * in the transcript, the same offer over the host page, and the quotation
+ * itself.
+ *
+ * Owned one-to-one by an `<ag-ui-chat>`, and holding no state outside the
+ * instance.
+ */
+export declare class TranscriptQuoteOffer {
+    #private;
+    /**
+     * Offer to quote the current selection, floated beside it.
+     *
+     * Shares the transcript's positioning box with the jump button for the same
+     * reason: it is positioned against the transcript, and must not scroll away
+     * with the words it is pointing at.
+     */
+    readonly button: HTMLButtonElement;
+    constructor(host: TranscriptQuoteHost);
+    /** The quotation behind `AgUiChat.quote`, whose doc is the contract. */
+    insert(text: string): void;
+    /** The offer behind `AgUiChat.offerQuoteInPage`, whose doc is the contract. */
+    offerInPage(within: HTMLElement): () => void;
+    /**
+     * Take the host-page offer down. It listens on the host's document, not on
+     * anything of ours, so nothing else would ever take it down.
+     */
+    detachPageOffer(): void;
+    /**
+     * Build the offer and listen for settled selections in the transcript.
+     *
+     * The button and the transcript outlive a connection, so the listeners go
+     * under `signal`, which the element aborts when it leaves the document.
+     */
+    mount(signal: AbortSignal): void;
+}
+//# sourceMappingURL=transcript_quote_offer.d.ts.map

package/dist/ui/excerpts/transcript_quote_offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript_quote_offer.d.ts","sourceRoot":"","sources":["../../../src/ui/excerpts/transcript_quote_offer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,gEAAgE;AAChE,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC;IACnC,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC;IAClC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAoB;;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAoC;IAQtE,YAAY,IAAI,EAAE,mBAAmB,EAEpC;IAED,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAgBzB;IAED,+EAA+E;IAC/E,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI,CAe3C;IAED;;;OAGG;IACH,eAAe,IAAI,IAAI,CAGtB;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAoC/B;CAiCF"}

package/dist/ui/fill_ui_string.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fill the `{token}` placeholders of a string-table template.
+ *
+ * Every string-table template goes through here rather than through
+ * `template.replace("{token}", value)`, which was wrong in two ways at once:
+ *
+ * - **A string replacement interprets dollar patterns in the value.** `$&`
+ *   inserts the matched token, and `` $` `` and `$'` the text either side of it,
+ *   so a queued message reading `costs $& more` was labelled
+ *   `Do not send "costs {text} more"`. Several of these values are text a user
+ *   or a server wrote -- a queued message, a tool name, a skill title, an
+ *   agent name -- so the value has to land verbatim. A replacer function's
+ *   return value is never interpreted, which is the whole fix.
+ * - **A string pattern replaces only the first occurrence**, so a translation
+ *   that uses a token twice was left half filled.
+ *
+ * One pass over the template, so a value that itself contains a `{token}` is
+ * inserted as written rather than filled in turn: a skill titled
+ * `Fill {fields}` stays that, where chained replacements filled it twice.
+ *
+ * A token with no entry in `values` is left as written. Every call site passes
+ * the tokens its key documents, so that is a translation carrying a token the
+ * call site does not know, and printing it is more honest than dropping it.
+ * `skills/fill_template.ts` is the prompt-side counterpart, and its contract is
+ * different on purpose: a prompt reports what it could not fill so a send can
+ * be refused.
+ *
+ * @param template - A string-table value, e.g. `strings.removeQueued`.
+ * @param values - The value for each token the template's key documents.
+ */
+export declare function fillUiString(template: string, values: Readonly<Record<string, string | number>>): string;
+//# sourceMappingURL=fill_ui_string.d.ts.map

package/dist/ui/fill_ui_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill_ui_string.d.ts","sourceRoot":"","sources":["../../src/ui/fill_ui_string.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,GAChD,MAAM,CAIR"}

package/dist/ui/history/checkpoint_menu.d.ts

@@ -0,0 +1,41 @@
+import type { RunRow } from "../../core/run_index.js";
+import { type UiStrings } from "../ui_strings.js";
+import { type RelativeTimeFormatter } from "./relative_time.js";
+/** How the host continues a picked run. */
+export type CheckpointVerb = "resume" | "fork";
+/**
+ * The checkpoint panel: continuable runs, each offering **resume** or **fork**.
+ *
+ * Deliberately separate from the thread drawer: a thread is a conversation you
+ * switch to, a checkpoint is a run you continue from, and one thread holds
+ * many. One list would make "resume" read as "open", when resuming starts a new
+ * run seeded from a snapshot.
+ *
+ * The host feeds only rows the server marked `continuable`, a run without a
+ * snapshot having nothing to resume from. Pure DOM, like {@link SkillsMenu}:
+ * append {@link element}, toggle it, feed {@link setRuns}, act on
+ * {@link onPick}.
+ */
+export declare class CheckpointMenu {
+    #private;
+    /** The panel root. Append to the chat shell; hidden until opened. */
+    readonly element: HTMLDivElement;
+    constructor(onPick: (runId: string, verb: CheckpointVerb) => void, strings?: UiStrings);
+    /** Replace the rows. The host passes only `continuable` runs. */
+    setRuns(runs: readonly RunRow[]): void;
+    /** Re-localize a panel built before the host's strings resolved. */
+    /**
+     * Replace the timestamp formatter, or restore the built-in with `null`.
+     *
+     * The built-in is deliberately locale-neutral -- there is no `Intl` anywhere
+     * in this component, so it never disagrees with a host's own formatting by
+     * guessing a locale. That is a defensible default and a poor requirement, so
+     * this is the way out.
+     */
+    setRelativeTimeFormatter(format: RelativeTimeFormatter | null): void;
+    setStrings(strings: UiStrings): void;
+    open(): void;
+    close(): void;
+    get open_(): boolean;
+}
+//# sourceMappingURL=checkpoint_menu.d.ts.map

package/dist/ui/history/checkpoint_menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_menu.d.ts","sourceRoot":"","sources":["../../../src/ui/history/checkpoint_menu.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,KAAK,qBAAqB,EAAgB,MAAM,oBAAoB,CAAC;AAG9E,2CAA2C;AAC3C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;AAqB/C;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAc;;IACzB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAWjC,YACE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,KAAK,IAAI,EACrD,OAAO,GAAE,SAA8B,EA+BxC;IAED,iEAAiE;IACjE,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAGrC;IAED,oEAAoE;IACpE;;;;;;;OAOG;IACH,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI,CAEnE;IASD,UAAU,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAKnC;IAED,IAAI,IAAI,IAAI,CAcX;IAED,KAAK,IAAI,IAAI,CAOZ;IAqCD,IAAI,KAAK,IAAI,OAAO,CAEnB;CAoHF"}

package/dist/ui/history/conversation_history.d.ts

@@ -0,0 +1,317 @@
+import { type Message } from "@ag-ui/core";
+import type { ActivityRegistry } from "../../core/activity_registry.js";
+import type { AgUiClient } from "../../core/agui_client.js";
+import type { ClientSeed } from "../../core/client_seed.js";
+import type { ClientConversationStore, NavigationCheckpoint, ThreadMeta } from "../../core/conversation_store.js";
+import type { ThreadDetail } from "../../core/events/thread_detail.js";
+import type { MessageRole } from "../../core/message_role.js";
+import { RunIndex } from "../../core/run_index.js";
+import type { ToolCatalog } from "../../tools/tool_catalog.js";
+import type { AnswerActions } from "../transcript/answer_actions.js";
+import type { Transcript } from "../transcript/transcript.js";
+import type { UiStrings } from "../ui_strings.js";
+import type { CheckpointMenu, CheckpointVerb } from "./checkpoint_menu.js";
+import type { RelativeTimeFormatter } from "./relative_time.js";
+import type { ThreadDrawer } from "./thread_drawer.js";
+/** What conversation history needs from the element that owns it. */
+export interface ConversationHistoryHost {
+    /**
+     * The custom element: the attributes history reads and stamps, and the
+     * `this` a host's `agentFactory` and `navigationResult` are called with.
+     */
+    readonly element: HTMLElement;
+    /** The conversation list, which the element builds and renders. */
+    readonly drawer: ThreadDrawer;
+    /** The checkpoint panel, which the element builds and renders. */
+    readonly checkpoints: CheckpointMenu;
+    /** The transcript a restored conversation is replayed into. */
+    readonly transcript: Transcript;
+    /** The action row under each finished answer. */
+    readonly actions: AnswerActions;
+    /** The activity renderers, which redraw a restored activity. */
+    readonly activities: ActivityRegistry;
+    /** The frontend tools, whose renderers a restored call is redrawn with. */
+    readonly tools: ToolCatalog;
+    /** The composer, whose text a continuation sends. */
+    readonly input: HTMLTextAreaElement;
+    /** The one-line hint above the composer. */
+    readonly hint: HTMLDivElement;
+    /** The resolved string table. */
+    readonly strings: () => UiStrings;
+    /** The element's `conversationStore`, read per use. */
+    readonly conversationStore: () => ClientConversationStore;
+    /** The element's `formatRelativeTime`. */
+    readonly formatRelativeTime: () => RelativeTimeFormatter | null;
+    /** The element's `navigationResult`. */
+    readonly navigationResult: () => (checkpoint: NavigationCheckpoint) => unknown;
+    /** The request headers, having first reported the destination if it is foreign. */
+    readonly headersFor: (url: string) => Record<string, string>;
+    /** The configured cookie policy as `fetch` spells it. */
+    readonly requestCredentials: () => RequestCredentials | undefined;
+    /** The element's `appendMessage`, which a restored bubble opens through. */
+    readonly appendMessage: (role: MessageRole, content: string) => HTMLDivElement;
+    /**
+     * Draw a turn the user sent and dispatch the submit event, as the element's
+     * own send does before it starts a run.
+     */
+    readonly announceTurn: (content: string) => void;
+    /**
+     * Record a turn taken from the composer for arrow-key recall, as the
+     * element's own send records one.
+     */
+    readonly recordTurn: (content: string) => void;
+    /** Resize the composer to its content. */
+    readonly autoGrow: () => void;
+    /**
+     * A continuation has ended, whether or not it ever ran.
+     *
+     * The composer parks a turn typed while one is in flight, and learns a run
+     * has settled from its own events -- which never arrive for a continuation
+     * that failed before starting one. Without this, such a turn stayed parked
+     * with nothing left to release it.
+     */
+    readonly continuationEnded: () => void;
+    /** The conversation's own client, or `null` until one is built. */
+    readonly client: () => AgUiClient | null;
+    /** The conversation's own client, built on first use. */
+    readonly ensureClient: () => AgUiClient;
+    /**
+     * A client from the same construction as the conversation's own, differing
+     * only in what `seed` says. A continuation's comes from here so that nothing
+     * added to one can be missing from the other.
+     */
+    readonly buildClient: (seed: ClientSeed) => AgUiClient;
+    /**
+     * Forget the conversation's own client, so the next one is built from
+     * {@link ConversationHistory.restored}. Nothing is cancelled: this is for a
+     * client that is not running.
+     */
+    readonly releaseClient: () => void;
+    /**
+     * Whether an interaction is in flight, which the composer owns: from the
+     * moment a send or a retry is taken, or a restore starts loading, not only
+     * once its run has started.
+     */
+    readonly running: () => boolean;
+    /**
+     * Hold the composer as a send holds it from the moment it is taken: the
+     * built-in Send parks its turn, a Retry and a pick refuse. Let go of when the
+     * run starts, by a Stop, or by {@link RunHold.release}.
+     *
+     * A host's send refuses too, unless `restored` is given: then the hold is a
+     * restore's with no run to resume, and a host's send waits for `restored` to
+     * settle and sends after it, with the conversation drawn. `restored` settles
+     * once that restore has ended, or has been stopped, and never rejects.
+     */
+    readonly holdRun: (restored: Promise<void> | null) => RunHold;
+    /** Stop the in-flight run. */
+    readonly cancelRun: () => void;
+    /** Drop the in-memory run and transcript, leaving the thread untouched. */
+    readonly resetState: () => void;
+    /** Swap the composer between Send and Stop, which the composer owns. */
+    readonly setRunning: (running: boolean) => void;
+    /**
+     * Say the conversation on screen changed, once its transcript is replaced.
+     * The element fills in the thread it replaced, which it last reported.
+     */
+    readonly threadChanged: (threadId: string, reason: ThreadDetail["reason"]) => void;
+    /** Hear the rows the conversation list was just given, for the title on screen. */
+    readonly threadsListed: (threads: readonly ThreadMeta[]) => void;
+    /** A thread was deleted, so whatever the element kept about it goes too. */
+    readonly threadDeleted: (threadId: string) => void;
+}
+/**
+ * A hold {@link ConversationHistoryHost.holdRun} took.
+ *
+ * It says nothing about whether the restore that took it was stopped. A
+ * restore asks its generation that, because a host's send that waited on a
+ * restore with no run to resume takes the hold over from it, and a restore
+ * stopped by a newer one finds that one's hold in its place -- see
+ * {@link ConversationHistory.rehydrate}.
+ */
+interface RunHold {
+    /**
+     * Let go, if nothing else has, and send what the composer parked behind it,
+     * because no run is going to settle and send it.
+     */
+    readonly release: () => void;
+}
+/**
+ * Which conversation is on screen, and how one gets there: restoring it from
+ * the store, switching to another from the conversation list, and continuing
+ * a run from the checkpoint panel.
+ *
+ * The one writer of the active thread's id and of the messages a restore
+ * seeded the next client with. The element reads both when it builds its
+ * client, and asks for a transition -- adopt the store's thread, mint a new
+ * one -- rather than writing either. Clearing the run, the transcript and the
+ * composer around a transition stays the element's, because it spans every
+ * part of it; history calls back for that.
+ *
+ * Owned one-to-one by an `<ag-ui-chat>`, and holding no state outside the
+ * instance.
+ */
+export declare class ConversationHistory {
+    #private;
+    constructor(host: ConversationHistoryHost);
+    /** The active thread's id. */
+    get threadId(): string;
+    /** The conversation as last written, for seeding the next client. */
+    get restored(): readonly Message[];
+    /** The checkpoint continuation in flight, or `null` when none is running. */
+    get continuation(): AgUiClient | null;
+    /** Point at the thread the store says is active. */
+    adoptActiveThread(): void;
+    /** Make a freshly minted thread the active one. */
+    startThread(): void;
+    /**
+     * Stop the checkpoint continuation in flight, if there is one.
+     *
+     * A continuation runs on a client of its own, which the element never held,
+     * so Stop cancelled the conversation's client and left this one streaming:
+     * the button read Stop and did nothing, and New chat, a thread switch or
+     * removing the element carried on drawing the resumed answer into whatever
+     * came next. The element calls this wherever it stops its own run.
+     */
+    stopContinuation(): void;
+    /** Forget the messages the last restore seeded, with the rest of the run. */
+    forgetRestored(): void;
+    /** Delete the active thread if nothing was ever sent in it. */
+    reapUnsent(): void;
+    /** The run index, built once from `data-runs-url`; `null` when unset. */
+    runs(): RunIndex | null;
+    /** Open the conversation list, dismissing the checkpoint panel. */
+    openThreads(): void;
+    /** Open the checkpoint panel, dismissing the conversation list. */
+    openCheckpoints(): void;
+    /**
+     * Switch the active conversation to an existing thread and replay it.
+     *
+     * A call for the thread a switch is already loading is handed that switch's
+     * own promise, so it settles when the thread is drawn rather than at once,
+     * before the replay.
+     *
+     * A store that rejects the load leaves the element on the thread it was on:
+     * the switch has already cleared the transcript, so it points back at the
+     * old thread and draws it again, saying nothing, and then rejects with the
+     * store's error. Left as it was, the element named a thread it was not
+     * showing and never reported it.
+     */
+    switchThread(threadId: string): Promise<void>;
+    /** Rename a thread, then reload the list that shows its title. */
+    renameThread(threadId: string, title: string): void;
+    /** Delete a thread; if it was the active one, fall back to a fresh chat. */
+    deleteThread(threadId: string): void;
+    /** Reload the drawer's thread list, marking the active thread. */
+    refreshDrawer(): Promise<void>;
+    /**
+     * Continue `runId` as a **new** run, seeded server-side from its snapshot.
+     *
+     * Uses a short-lived agent pointed at the resume / fork endpoint and seeded
+     * with no history, because those endpoints supply the prior turns from the
+     * snapshot and re-sending them would duplicate. A separate agent makes that
+     * structural and mints the fresh `run_id` the endpoints also require.
+     *
+     * Built by the same construction as the conversation's own client, so the
+     * continuation streams into the same transcript the user is looking at and
+     * runs under the same state, tools and bounds. It is the run in flight while
+     * it lasts: {@link stopContinuation} is how the element's Stop reaches it.
+     *
+     * What it adds joins the conversation. Its saves write the conversation on
+     * screen ahead of its exchange, and each one hands that whole list to the
+     * next client the element builds, so the next ordinary message is sent with
+     * the exchange it follows. The conversation's own client never held it, and
+     * was sending without it.
+     */
+    continueRun(runId: string, verb: CheckpointVerb): Promise<void>;
+    /**
+     * Restore the conversation from the store on mount, then — if a navigating
+     * tool reloaded the page mid-run — resume the loop by supplying that tool's
+     * result from the page we landed on.
+     *
+     * Any other call the stored run left unanswered is answered on the way in, as
+     * not finished, because no run is left to answer it.
+     *
+     * **What the store holds after a reload mid-run.** The run loop persists a
+     * round when its stream ends, which is *before* it asks about a gated call,
+     * runs a frontend tool, or collects a server-side approval. A reload in that
+     * window leaves the round's calls stored with no result, and the request that
+     * would have produced one died with the page.
+     *
+     * **Why not finished, and not declined.** Stop declines an open card because
+     * pressing it is a person answering the question. A reload answers nothing, and
+     * the stored shape is the same whether the round waited on a person or on a
+     * handler the reload killed, so declined would be unproven for the first and
+     * false for the second. A marker saved while a card is open could tell them
+     * apart, but every host store would have to round-trip it, and a store that
+     * dropped it would fall back to this wording anyway -- which is true of both.
+     *
+     * The answers come from the same helper the client runs before each request,
+     * so a restored card and the result the next request carries cannot disagree.
+     * Giving them to the replay, rather than leaving the client to add them, is
+     * what settles each card from its result. The checkpointed call is excluded,
+     * because the resume path answers it from the page the reload landed on; that
+     * exclusion is held by "resumes with the landed page's result, and its card says
+     * so" in `ag_ui_chat_reload_mid_run.test.ts`.
+     *
+     * **Every restore holds the composer from before the load.** Until the
+     * store answers, the conversation's client can only be seeded from nothing.
+     * With a remote store that is a real request, and a send, a Retry or a pick
+     * in it was refused by nothing: each built the conversation's client before
+     * the conversation had loaded, so a send went out carrying none of it, its
+     * first save replaced the stored one, and the replay then drew the stored
+     * conversation under the new turn. The client stayed cached without it, so
+     * every later turn went out without it too. So the composer is held as a
+     * send holds it: what was typed parks and goes out after the replay, and a
+     * Retry and a pick are refused -- a Retry has nothing on screen to retry, and
+     * after the load it would re-ask the previous visit's last question.
+     *
+     * **A host's send waits for a restore with no run to resume.** It is
+     * usually a prompt fired as the element mounts, which no host could time
+     * against a load nothing announces, and refusing it would lose the turn.
+     * So it waits for this restore to end, taking the hold over as it does,
+     * and then sends with the conversation drawn above it; what the built-in
+     * Send parked goes out after its run. Stopped while it waits, it is dropped,
+     * as a send stopped by its own submit listener is.
+     *
+     * **A restore that resumes refuses a host's send instead.** The resume is a
+     * run, and the restore ends by starting it, so a send that waited would only
+     * reach that run and be refused there. The resume gives way to nothing: what
+     * was typed parks behind the resumed run and goes out after its answer.
+     *
+     * The other way round, the resume standing down for the send, was rejected.
+     * The send that got in first had already gone out without the conversation,
+     * so standing down kept that loss, and it also dropped the run the navigation
+     * was part of, which the user asked for before the reload: the agent stopped
+     * halfway through the task, with the navigating call never answered.
+     *
+     * **A restore stops where it was stopped, held or not.** New chat, a thread
+     * switch, a `user-key` handover, a newer restore or the element leaving the
+     * page can each come while the store answers, and from host code the restore
+     * runs itself: the activity and tool renderers each replayed message draws
+     * through, and `navigationResult`. From then on it draws nothing more and
+     * resumes nothing. The hold cannot say so, because a host's send that
+     * waited may hold it by then. So the restore asks its generation, which clearing
+     * the conversation moves on as a newer restore does, and asks it after the
+     * load, after each replayed message -- as a Retry asks after each one -- and
+     * once more before the resume. Stopped by anything but the element leaving
+     * the page, it also forgets the checkpoint it loaded, since that was a Stop
+     * for the run it would have resumed -- unless what replaced it is a restore
+     * of the same conversation, still current, which answers for that run
+     * instead; see `#forgetStopped`.
+     *
+     * `reason` is what the thread event this restore ends with reports as why
+     * the conversation changed. A restore that is stopped reports nothing, and
+     * neither does one given `null`, which draws the thread already reported.
+     */
+    rehydrate(reason: ThreadDetail["reason"] | null): Promise<void>;
+    /**
+     * Replay a restored message: text bubbles *and* tool activity. An assistant
+     * turn may carry `toolCalls` (rendered as cards) and/or text; a `tool` turn
+     * carries a result that settles the matching card. So a refreshed page shows
+     * the full transcript — tool calls and their results — not just the prose.
+     */
+    replay(message: Message): void;
+}
+export {};
+//# sourceMappingURL=conversation_history.d.ts.map

package/dist/ui/history/conversation_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation_history.d.ts","sourceRoot":"","sources":["../../../src/ui/history/conversation_history.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EACpB,UAAU,EACX,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,qEAAqE;AACrE,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC;IAClC,uDAAuD;IACvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;IAC1D,0CAA0C;IAC1C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,qBAAqB,GAAG,IAAI,CAAC;IAChE,wCAAwC;IACxC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,oBAAoB,KAAK,OAAO,CAAC;IAC/E,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7D,yDAAyD;IACzD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAClE,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,KAAK,cAAc,CAAC;IAC/E;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,IAAI,CAAC;IACvC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IACzC,yDAAyD;IACzD,QAAQ,CAAC,YAAY,EAAE,MAAM,UAAU,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;IACvD;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC;IAChC;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,OAAO,CAAC;IAC9D,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAChC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IACnF,mFAAmF;IACnF,QAAQ,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,KAAK,IAAI,CAAC;IACjE,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD;AAED;;;;;;;;GAQG;AACH,UAAU,OAAO;IACf;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAYD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,mBAAmB;;IAkD9B,YAAY,IAAI,EAAE,uBAAuB,EAExC;IAED,8BAA8B;IAC9B,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,qEAAqE;IACrE,IAAI,QAAQ,IAAI,SAAS,OAAO,EAAE,CAEjC;IAED,6EAA6E;IAC7E,IAAI,YAAY,IAAI,UAAU,GAAG,IAAI,CAEpC;IAED,oDAAoD;IACpD,iBAAiB,IAAI,IAAI,CAExB;IAED,mDAAmD;IACnD,WAAW,IAAI,IAAI,CAElB;IAED;;;;;;;;OAQG;IACH,gBAAgB,IAAI,IAAI,CAGvB;IAED,6EAA6E;IAC7E,cAAc,IAAI,IAAI,CAerB;IASD,+DAA+D;IAC/D,UAAU,IAAI,IAAI,CAOjB;IAED,yEAAyE;IACzE,IAAI,IAAI,QAAQ,GAAG,IAAI,CAatB;IAED,mEAAmE;IACnE,WAAW,IAAI,IAAI,CAQlB;IAED,mEAAmE;IACnE,eAAe,IAAI,IAAI,CAKtB;IAED;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa5C;IA0BD,kEAAkE;IAClE,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAGlD;IAED,4EAA4E;IAC5E,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAenC;IAED,kEAAkE;IAC5D,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAKnC;IAWD;;;;;;;;;;;;;;;;;;OAkBG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAiJpE;IAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+EG;IACG,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA6IpE;IAoID;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsG7B;CA2DF"}

package/dist/ui/history/history_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const HISTORY_STYLES: string;
+//# sourceMappingURL=history_styles.d.ts.map

package/dist/ui/history/history_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/history/history_styles.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,EAAE,MAwe5B,CAAC"}

package/dist/ui/history/relative_time.d.ts

@@ -0,0 +1,23 @@
+import { type UiStrings } from "../ui_strings.js";
+/**
+ * A compact relative timestamp for a thread row — e.g. `"just now"`, `"5m ago"`,
+ * `"3h ago"`, `"2d ago"`, `"4w ago"`.
+ *
+ * `now` is injectable so callers and tests can pin the reference point. A
+ * future timestamp (clock skew) and a non-finite one (an unparseable or missing
+ * `updated_at`, arriving as `NaN`) both read as `justNow`, rather than
+ * rendering a nonsense age. Unit words come from {@link UiStrings} with `{n}`
+ * filled in here; the bucketing stays integer-rounded and locale-neutral.
+ */
+export declare function relativeTime(timestamp: number, now?: number, strings?: UiStrings): string;
+/**
+ * A host's replacement for {@link relativeTime}.
+ *
+ * Takes an epoch-milliseconds timestamp and returns the text a row shows.
+ * `Intl.RelativeTimeFormat` is the obvious implementation and is deliberately
+ * *not* the default: a component that guessed a locale would disagree with the
+ * host page's own formatting, and being wrong in a second language is worse
+ * than being neutral in one.
+ */
+export type RelativeTimeFormatter = (timestamp: number) => string;
+//# sourceMappingURL=relative_time.d.ts.map

package/dist/ui/history/relative_time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative_time.d.ts","sourceRoot":"","sources":["../../../src/ui/history/relative_time.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEtE;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAmB,EACxB,OAAO,GAAE,SAA8B,GACtC,MAAM,CAqBR;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC"}

package/dist/ui/history/thread_drawer.d.ts

@@ -0,0 +1,64 @@
+import type { ThreadMeta } from "../../core/conversation_store.js";
+import { type UiStrings } from "../ui_strings.js";
+import { type RelativeTimeFormatter } from "./relative_time.js";
+/**
+ * How many conversations there have to be before the filter appears.
+ *
+ * A search box above a list you can already read in one glance is a control
+ * asking to be used on nothing.
+ */
+export declare const FILTER_FROM = 8;
+/**
+ * When the search box shows: from {@link FILTER_FROM} conversations (`auto`),
+ * over any list (`always`), or not at all (`never`).
+ */
+export type ThreadsSearch = "auto" | "always" | "never";
+/** Actions the host ({@link AgUiChat}) wires to the drawer's rows. */
+export interface ThreadDrawerCallbacks {
+    /** A row was picked — load that thread and make it active. */
+    readonly onSelect: (threadId: string) => void;
+    /** The "New chat" action — start a fresh thread. */
+    readonly onNew: () => void;
+    /** A row was renamed to `title`. */
+    readonly onRename: (threadId: string, title: string) => void;
+    /** A row was deleted (after the inline confirm). */
+    readonly onDelete: (threadId: string) => void;
+}
+/**
+ * The chat-history drawer: a slide-over listing the user's threads (title,
+ * relative time, preview), with select / new / rename / delete actions and an
+ * empty state. Pure DOM, like {@link SkillsMenu}: the host appends
+ * {@link element}, toggles it, feeds rows via {@link setThreads}, and acts on
+ * the callbacks.
+ *
+ * A view only — it never mutates the store. After a callback the host updates
+ * the store and calls {@link setThreads} to refresh. All visible text comes
+ * from {@link UiStrings}; {@link setStrings} re-localizes a drawer built before
+ * its strings resolved.
+ */
+export declare class ThreadDrawer {
+    #private;
+    /** The drawer root (backdrop + panel). Append to the chat shell; hidden until opened. */
+    readonly element: HTMLDivElement;
+    constructor(callbacks: ThreadDrawerCallbacks, strings?: UiStrings);
+    /** Re-localize the drawer's chrome and rows (the host calls this on connect). */
+    /**
+     * Replace the timestamp formatter, or restore the built-in with `null`.
+     *
+     * The built-in is deliberately locale-neutral -- there is no `Intl` anywhere
+     * in this component, so it never disagrees with a host's own formatting by
+     * guessing a locale. That is a defensible default and a poor requirement, so
+     * this is the way out.
+     */
+    setRelativeTimeFormatter(format: RelativeTimeFormatter | null): void;
+    setStrings(strings: UiStrings): void;
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    /** Choose when the search box shows; the host's `data-threads-search`. */
+    setSearchMode(mode: ThreadsSearch): void;
+    /** Render the rows (or the empty state), highlighting the active thread. */
+    setThreads(threads: readonly ThreadMeta[], activeId: string): void;
+}
+//# sourceMappingURL=thread_drawer.d.ts.map

package/dist/ui/history/thread_drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread_drawer.d.ts","sourceRoot":"","sources":["../../../src/ui/history/thread_drawer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,KAAK,qBAAqB,EAAgB,MAAM,oBAAoB,CAAC;AAG9E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAIxD,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/C;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAY;;IACvB,yFAAyF;IACzF,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAsBjC,YAAY,SAAS,EAAE,qBAAqB,EAAE,OAAO,GAAE,SAA8B,EA2EpF;IAED,iFAAiF;IACjF;;;;;;;OAOG;IACH,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI,CAEnE;IASD,UAAU,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAUnC;IAED,MAAM,IAAI,OAAO,CAEhB;IAED,IAAI,IAAI,IAAI,CAWX;IAED,KAAK,IAAI,IAAI,CAOZ;IAED,MAAM,IAAI,IAAI,CAMb;IAgCD,0EAA0E;IAC1E,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAGvC;IAED,4EAA4E;IAC5E,UAAU,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIjE;CAyNF"}

package/dist/ui/history/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function openerElement(root: Document | ShadowRoot): Element | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ui/history/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/ui/history/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,IAAI,CAUzE"}

package/dist/ui/interrupts/approval_card.d.ts

@@ -0,0 +1,64 @@
+import { type UiStrings } from "../ui_strings.js";
+/** What the inline approval card displays for one server-side-tool interrupt. */
+export interface ApprovalRequest {
+    /**
+     * Human-readable prompt from the AG-UI interrupt (e.g.
+     * `Approve delete_thing({…})?`). Falls back to the generic
+     * {@link UiStrings.approvalPrompt} when the interrupt carries no message.
+     */
+    message?: string;
+    /** Tool name, surfaced as a `data-tool-name` attribute for styling/tests. */
+    toolName?: string;
+    /**
+     * The call's arguments, shown for editing when {@link ApprovalOptions.onEdit}
+     * is set. Omitted when the interrupt names no call whose arguments are known.
+     */
+    args?: Record<string, unknown>;
+}
+/** Options for {@link requestApproval}. */
+export interface ApprovalOptions {
+    /**
+     * Aborting this signal resolves the card as denied, with buttons disabled and
+     * `data-resolved="denied"` — how a Stop control dismisses a pending approval.
+     */
+    signal?: AbortSignal;
+    /** Localized strings; defaults to the English {@link DEFAULT_UI_STRINGS}. */
+    strings?: UiStrings;
+    /**
+     * Offer the call's arguments for editing, and receive what the user approved.
+     *
+     * Called **only** on approval, and only when the text parses and differs from
+     * what was proposed -- an untouched call resolves as a plain approval, so a
+     * server sees `editedArgs` exactly when something was actually edited.
+     *
+     * Absent means no editor, which is deliberate: AG-UI gates this on the
+     * agent's own `approveWithEdits` capability, and a card that let a user
+     * rewrite arguments a server will discard is worse than one that does not
+     * offer to.
+     */
+    onEdit?: (args: Record<string, unknown>) => void;
+}
+/**
+ * A fully custom renderer for a server-side-tool approval, set via
+ * `AgUiChat.approvalRenderer`. Receives the {@link ApprovalRequest} and an
+ * `AbortSignal` that fires when the run is stopped, and resolves `true` to
+ * approve or `false` to deny. Replaces the built-in {@link requestApproval}
+ * card entirely, the host owning the DOM; to restyle the built-in card instead,
+ * use the `strings` and `::part()` seams.
+ */
+export type ApprovalRenderer = (request: ApprovalRequest, options: {
+    signal: AbortSignal;
+}) => Promise<boolean>;
+/**
+ * Append an inline approval card to `host` and resolve `true` to run a gated
+ * server-side tool or `false` to deny it.
+ *
+ * Distinct from the client-tool confirmation card
+ * ({@link requestConfirmation}): a gated server tool defers instead of
+ * executing, so the run finishes on an AG-UI interrupt the client answers with
+ * `resume[]`, and this is the browser half of that loop. Unlike the
+ * confirmation card, this one stays in the transcript as a resolved record,
+ * buttons disabled and `data-resolved` set.
+ */
+export declare function requestApproval(host: Node & ParentNode, request: ApprovalRequest, options?: ApprovalOptions): Promise<boolean>;
+//# sourceMappingURL=approval_card.d.ts.map