@cosmoops/connect-sdk 0.28.0 → 0.30.0

package/dist/cjs/server/resources/ai.js

@@ -33,6 +33,10 @@ class AiResource {
             json: {
                 workspaceId: input.workspaceId,
                 messages: input.messages,
+                // Omitted when absent, which is how a caller opts out of history: no
+                // id, nothing stored. Connect also stores nothing for a call carrying
+                // no `asUser`, because a conversation belongs to a person.
+                ...(input.conversationId ? { conversationId: input.conversationId } : {}),
                 // Omitted entirely when absent, rather than sent as `undefined` - an
                 // application that describes no screens should send no field.
                 ...(input.screens ? { screens: input.screens } : {}),
@@ -43,6 +47,57 @@ class AiResource {
             signal: options.signal,
         });
     }
+    /**
+     * The signed-in user's past conversations in your application, most recent
+     * first.
+     *
+     * `asUser` is required rather than optional here, unlike on `chat`: the rows
+     * are scoped to a person, and there is no application-wide view of them to
+     * fall back to. Connect reads the user and the workspace from the token.
+     *
+     * Cursor-paginated with no total - the list is ordered by last use, which
+     * moves while it is being read.
+     */
+    listConversations(input) {
+        const query = new URLSearchParams();
+        if (input.limit !== undefined)
+            query.set("limit", String(input.limit));
+        if (input.cursor)
+            query.set("cursor", input.cursor);
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        return (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: `/ai/conversations${suffix}`,
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
+    /**
+     * One stored transcript, oldest turn first.
+     *
+     * `turns[].parts` comes back exactly as the model produced it - prose,
+     * reasoning and tool calls in order - so it can be handed straight back to a
+     * chat UI. Not this user's, or not your application's, is a `404` either way.
+     */
+    getConversation(input) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: `/ai/conversations/${encodeURIComponent(input.conversationId)}`,
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
+    /**
+     * Deletes a conversation and every turn beneath it.
+     *
+     * Idempotent - one already gone answers `{ deleted: true }`, so a retry after
+     * a dropped response does not read as a failure.
+     */
+    deleteConversation(input) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "DELETE",
+            path: `/ai/conversations/${encodeURIComponent(input.conversationId)}`,
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
     /** Extract structured JSON from a file or image URL, against a platform extraction schema referenced by id. */
     async extract(input) {
         const result = await (0, http_js_1.request)(this.transport, {

package/dist/cjs/server/resources/conversations.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationsResource = void 0;
+const http_js_1 = require("../http.js");
+const acting_as_js_1 = require("./acting-as.js");
+/**
+ * What a workspace's agents are saying in writing.
+ *
+ * **The sibling of `calls`, with one difference that decides how it is
+ * gated: these are the *workspace's* threads, not your application's.** A call
+ * arrived on a channel you hold, so `calls.list` is scoped to your
+ * application. A conversation lives in the workspace's own subtree and belongs
+ * to it the way its contact book does - so reading one needs a live
+ * subscription in that workspace, and, when the call comes from a browser
+ * through the bridge, the signed-in member's own `agent:read`.
+ *
+ * Read-only, and deliberately. Sending on a thread is not a missing verb:
+ * inside WhatsApp's 24-hour window a reply is the agent's to make, outside it
+ * only an approved template may be sent, and posting into a thread would mean
+ * saying which of those it was and what it means for the agent still
+ * answering.
+ */
+class ConversationsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * The workspace's threads, newest activity first.
+     *
+     * **Page until `hasMore` is `false`; do not stop on an empty `items`.** An
+     * inbox grows without bound, so there is no total count to page against.
+     */
+    list(input) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: "/conversations",
+            query: {
+                workspaceId: input.workspaceId,
+                contactAddress: input.contactAddress,
+                status: input.status,
+                cursor: input.cursor,
+                limit: input.limit === undefined ? undefined : String(input.limit),
+            },
+            headers: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
+    /**
+     * One thread and its recent messages, oldest first.
+     *
+     * **Capped, not paged** - you get the same window the agent itself sees when
+     * it composes a reply, so you are never shown less context than it used.
+     *
+     * Turns that produced no message are included and carry `failure`. Render
+     * them: a transcript that silently drops them reads as a customer being
+     * ignored, which is the opposite of what happened.
+     *
+     * Throws `ConnectError` with `code: "not_found"` for a thread this workspace
+     * does not hold.
+     */
+    get(conversationId, options) {
+        return (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: `/conversations/${encodeURIComponent(conversationId)}`,
+            query: { workspaceId: options.workspaceId },
+            headers: (0, acting_as_js_1.actingAs)(options.asUser),
+        });
+    }
+}
+exports.ConversationsResource = ConversationsResource;

package/dist/esm/client/components/ask-ai-history.js

@@ -0,0 +1,103 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Button } from "@heroui/react";
+import { MessageSquare, Trash2 } from "lucide-react";
+import { useConnect } from "../provider.js";
+/** Bridge paths, spelled once - the list is read and invalidated from three places. */
+const LIST_PATH = "/ai/conversations";
+const detailPath = (id) => `/ai/conversation?id=${encodeURIComponent(id)}`;
+/**
+ * Past Ask AI conversations, for reopening or deleting.
+ *
+ * ## It fetches only while it is open
+ *
+ * `<ConnectAskAi>` is mounted for the whole application shell, so an
+ * unconditional read here would put a request on every page load to populate a
+ * list most people never open. It reads on open, and again whenever the panel
+ * has written a new conversation since - which is what `refreshKey` is for.
+ *
+ * ## Deletion confirms inline, not in a dialog
+ *
+ * Destructive actions confirm; this one does it at the weight it deserves.
+ * Losing a transcript is recoverable by asking again, not a cancelled
+ * subscription, and a modal over a 400px panel would be heavier than the thing
+ * it guards. The row swaps to "Delete? / Cancel" and stays there until
+ * answered.
+ */
+export function AskAiHistory({ refreshKey, activeConversationId, onOpenConversation, }) {
+    const { fetchResource, mutateResource, invalidateResource } = useConnect();
+    const [conversations, setConversations] = useState(null);
+    const [error, setError] = useState(null);
+    const [confirmingId, setConfirmingId] = useState(null);
+    const [busyId, setBusyId] = useState(null);
+    useEffect(() => {
+        let active = true;
+        // The cached entry is dropped first. This component mounts only when the
+        // user asks for the list, and the provider's cache would otherwise hand
+        // them the copy taken before the last three questions they asked.
+        invalidateResource(LIST_PATH);
+        fetchResource(LIST_PATH)
+            .then((page) => {
+            if (!active)
+                return;
+            setConversations(page.conversations);
+            setError(null);
+        })
+            .catch((cause) => {
+            if (!active)
+                return;
+            // An empty list rather than a permanent skeleton: the error is shown
+            // beside it, and a panel stuck loading says nothing at all.
+            setConversations([]);
+            setError(cause instanceof Error ? cause.message : "Could not load your conversations");
+        });
+        return () => {
+            active = false;
+        };
+    }, [fetchResource, invalidateResource, refreshKey]);
+    const open = async (id) => {
+        setBusyId(id);
+        try {
+            const detail = await fetchResource(detailPath(id));
+            onOpenConversation(id, detail);
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : "Could not open that conversation");
+        }
+        finally {
+            setBusyId(null);
+        }
+    };
+    const remove = async (id) => {
+        setBusyId(id);
+        // Removed from the list before the response lands. The confirmation was the
+        // decision point, and a row that lingers while the request flies reads as a
+        // press that did not take - so the list is patched and put back on failure.
+        const previous = conversations;
+        setConversations((current) => current?.filter((row) => row.id !== id) ?? null);
+        setConfirmingId(null);
+        try {
+            await mutateResource(detailPath(id), undefined, "DELETE");
+            invalidateResource(LIST_PATH);
+        }
+        catch (cause) {
+            setConversations(previous);
+            setError(cause instanceof Error ? cause.message : "Could not delete that conversation");
+        }
+        finally {
+            setBusyId(null);
+        }
+    };
+    if (conversations === null) {
+        return (_jsx("div", { className: "space-y-2 p-4", "aria-busy": "true", children: [0, 1, 2].map((row) => (_jsx("div", { className: "h-9 animate-pulse rounded-md bg-surface-secondary" }, row))) }));
+    }
+    if (conversations.length === 0) {
+        return (_jsx("div", { className: "p-4", children: error ? (_jsx("p", { className: "text-xs text-danger", children: error })) : (_jsx("p", { className: "text-center text-xs text-muted", children: "Nothing here yet. Conversations you have are saved automatically." })) }));
+    }
+    return (_jsxs("div", { className: "p-2", children: [error && _jsx("p", { className: "px-2 pb-2 text-xs text-danger", children: error }), _jsx("ul", { className: "space-y-0.5", children: conversations.map((conversation) => {
+                    const isConfirming = confirmingId === conversation.id;
+                    const isActive = conversation.id === activeConversationId;
+                    return (_jsx("li", { children: isConfirming ? (_jsxs("div", { className: "flex items-center gap-2 rounded-md border border-border px-2 py-1.5", children: [_jsx("span", { className: "flex-1 truncate text-xs text-muted", children: "Delete this conversation?" }), _jsx(Button, { size: "sm", variant: "danger", className: "h-7 px-2 text-xs", isDisabled: busyId === conversation.id, onPress: () => void remove(conversation.id), children: "Delete" }), _jsx(Button, { size: "sm", variant: "tertiary", className: "h-7 px-2 text-xs", onPress: () => setConfirmingId(null), children: "Cancel" })] })) : (_jsxs("div", { className: `group flex items-center gap-1 rounded-md ${isActive ? "bg-surface-secondary" : ""}`, children: [_jsxs(Button, { variant: "ghost", className: "h-auto min-w-0 flex-1 justify-start gap-2 px-2 py-1.5 text-start", isDisabled: busyId === conversation.id, onPress: () => void open(conversation.id), children: [_jsx(MessageSquare, { className: "size-3.5 shrink-0 text-muted" }), _jsx("span", { className: "min-w-0 flex-1 truncate text-xs font-normal", children: conversation.title })] }), _jsx(Button, { isIconOnly: true, size: "sm", variant: "ghost", className: "shrink-0", "aria-label": `Delete "${conversation.title}"`, onPress: () => setConfirmingId(conversation.id), children: _jsx(Trash2, { className: "size-3.5 text-muted" }) })] })) }, conversation.id));
+                }) })] }));
+}

package/dist/esm/client/components/ask-ai-turns.js

@@ -0,0 +1,82 @@
+/**
+ * Index of the final text block, or `-1`. A reverse loop rather than
+ * `findLastIndex`, which is ES2023 - this package targets ES2022 so its
+ * published output stays usable on the runtimes its `engines` field claims.
+ */
+export function lastTextBlockIndex(blocks) {
+    for (let index = blocks.length - 1; index >= 0; index--) {
+        if (blocks[index]?.kind === "text")
+            return index;
+    }
+    return -1;
+}
+/** Appends a text delta to the open text block, or opens one after a widget. */
+export function appendText(blocks, text) {
+    const last = blocks.at(-1);
+    if (last?.kind === "text") {
+        return [...blocks.slice(0, -1), { kind: "text", text: last.text + text }];
+    }
+    return [...blocks, { kind: "text", text }];
+}
+/**
+ * Rebuilds the panel's turns from a stored transcript.
+ *
+ * The inverse of what the stream reader does live, and it has to agree with it
+ * or a reopened conversation renders differently from the one the user just
+ * had. Two shapes, one source: the stream delivers `text-delta`,
+ * `reasoning-delta` and `tool-input-available` frames, and storage keeps the
+ * settled `UIMessage` parts those frames built - `{ type: "text" }`,
+ * `{ type: "reasoning" }`, and `{ type: "tool-<name>" }` carrying the input the
+ * widget was drawn from.
+ *
+ * Three rules, each of which is a thing that would otherwise render wrong:
+ *
+ * - **A tool part with no input is dropped, not restored.** `input: null` means
+ *   "still arriving" to the renderer, which draws a skeleton - correct live,
+ *   and a shimmer that never resolves on a transcript that finished days ago.
+ * - **Reasoning is hoisted per turn**, not left in place. It is rendered above
+ *   the answer in a disclosure, which is where it sat while streaming.
+ * - **A part this build cannot place is skipped rather than guessed at.**
+ *   `parts` is the AI SDK's own shape and gains kinds over time; an unknown one
+ *   costs a widget, and inventing a rendering for it costs the whole turn.
+ */
+export function turnsFromStored(turns) {
+    return turns.map((turn) => {
+        let blocks = [];
+        let reasoning = "";
+        for (const raw of turn.parts) {
+            const part = raw;
+            if (typeof part?.type !== "string")
+                continue;
+            if (part.type === "text") {
+                if (typeof part.text === "string" && part.text.length > 0) {
+                    blocks = appendText(blocks, part.text);
+                }
+                continue;
+            }
+            if (part.type === "reasoning") {
+                if (typeof part.text === "string")
+                    reasoning += part.text;
+                continue;
+            }
+            if (part.type.startsWith("tool-")) {
+                // See the note above: an absent input is a skeleton forever.
+                if (part.input === undefined || part.input === null)
+                    continue;
+                blocks = [
+                    ...blocks,
+                    {
+                        kind: "tool",
+                        // The stored call id when there is one. Falling back to the block's
+                        // position keeps React keys unique within the turn, which is all
+                        // this id is used for once the turn is settled.
+                        id: typeof part.toolCallId === "string" ? part.toolCallId : `${turn.id}-${blocks.length}`,
+                        name: part.type.slice("tool-".length),
+                        input: part.input,
+                    },
+                ];
+            }
+        }
+        return { id: turn.id, role: turn.role, blocks, reasoning };
+    });
+}

package/dist/esm/client/components/ask-ai.js

@@ -2,12 +2,14 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Button, Input, Label, TextField } from "@heroui/react";
-import { Brain, ChevronDown, Send, Sparkles, Square, X } from "lucide-react";
+import { Brain, ChevronDown, History, Plus, Send, Sparkles, Square, X } from "lucide-react";
 import { Streamdown } from "streamdown";
 import { useConnect } from "../provider.js";
 import { useActivePath } from "../use-active-path.js";
 import { matchConnectScreen } from "./ai-screens.js";
 import { AiActions, AiChart, AiDetails, AiMetrics, AiSources, AiSteps, AiTable, AiTimeline } from "./ai-widgets.js";
+import { AskAiHistory } from "./ask-ai-history.js";
+import { appendText, lastTextBlockIndex, turnsFromStored, } from "./ask-ai-turns.js";
 /**
  * The panel's open width. The *inner* pane always carries it, so the content
  * keeps its layout while the outer shell's width animates to zero around it.
@@ -167,26 +169,6 @@ async function readStream(response, onChunk) {
         }
     }
 }
-/**
- * Index of the final text block, or `-1`. A reverse loop rather than
- * `findLastIndex`, which is ES2023 - this package targets ES2022 so its
- * published output stays usable on the runtimes its `engines` field claims.
- */
-function lastTextBlockIndex(blocks) {
-    for (let index = blocks.length - 1; index >= 0; index--) {
-        if (blocks[index]?.kind === "text")
-            return index;
-    }
-    return -1;
-}
-/** Appends a text delta to the open text block, or opens one after a widget. */
-function appendText(blocks, text) {
-    const last = blocks.at(-1);
-    if (last?.kind === "text") {
-        return [...blocks.slice(0, -1), { kind: "text", text: last.text + text }];
-    }
-    return [...blocks, { kind: "text", text }];
-}
 /**
  * Ask AI - a chat panel grounded in the signed-in workspace's Context Index,
  * streamed through your own bridge.
@@ -235,6 +217,31 @@ export function ConnectAskAi({ title = "Ask AI", assistantName = "Assistant", pl
     const [input, setInput] = useState("");
     const [isBusy, setIsBusy] = useState(false);
     const [error, setError] = useState(null);
+    const [showHistory, setShowHistory] = useState(false);
+    /**
+     * The conversation being written to.
+     *
+     * Generated here, before the first message, because the server cannot hand
+     * one back: it is streaming a response, and there is no point in that stream
+     * at which a new id could reach the browser ahead of the first token. So the
+     * client picks it and Connect upserts - safe because ownership is checked
+     * rather than assumed, and an id naming somebody else's conversation is
+     * refused.
+     *
+     * Lazily initialised rather than computed in a `useMemo`: this has to survive
+     * re-renders and change only when the user starts a new conversation, which
+     * is precisely what `useMemo` does not promise.
+     */
+    const [conversationId, setConversationId] = useState(() => newConversationId());
+    /**
+     * Bumped whenever a turn has been written, so the history list re-reads the
+     * next time it is opened.
+     *
+     * A counter rather than a refetch call, because the list is unmounted while
+     * closed - there is nothing to tell. It is *why* the list re-reads, not the
+     * list itself.
+     */
+    const [writeCount, setWriteCount] = useState(0);
     const abortRef = useRef(null);
     const bottomRef = useRef(null);
     // Ids only have to be unique within one mounted conversation, so a counter is
@@ -309,6 +316,11 @@ export function ConnectAskAi({ title = "Ask AI", assistantName = "Assistant", pl
                 // decide what anyone may do. See `ConnectScreen`.
                 ...(resolvedPath ? { screenContext: { pathname: resolvedPath } } : {}),
                 ...(screens.length > 0 ? { screens } : {}),
+                // What makes the conversation resumable. Connect stores the turn
+                // against it and `<AskAiHistory>` reads it back; a turn sent
+                // without one is answered exactly the same way and remembered by
+                // nobody.
+                conversationId,
             }, { signal: controller.signal });
             // The assistant's turn is appended only once the stream is live, so a
             // failed request leaves an error under the question rather than an
@@ -345,8 +357,41 @@ export function ConnectAskAi({ title = "Ask AI", assistantName = "Assistant", pl
             if (abortRef.current === controller)
                 abortRef.current = null;
             setIsBusy(false);
+            // Even on an aborted or failed turn: the user's own question has
+            // already been persisted by the time anything can go wrong downstream
+            // of it, so the list is stale either way.
+            setWriteCount((count) => count + 1);
         }
-    }, [streamResource, turns]);
+    }, [streamResource, turns, conversationId]);
+    /**
+     * Clears the transcript and starts writing into a fresh conversation.
+     *
+     * The old one is not deleted - it is in History, which is the whole point.
+     */
+    const startNewConversation = useCallback(() => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        setIsBusy(false);
+        setTurns([]);
+        setError(null);
+        setShowHistory(false);
+        setConversationId(newConversationId());
+    }, []);
+    /**
+     * Replaces the transcript with a stored one, and continues writing into it.
+     *
+     * Writing continues into the conversation that was opened rather than forking
+     * a new one, which is what makes "come back to this tomorrow" work at all.
+     */
+    const openConversation = useCallback((id, detail) => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        setIsBusy(false);
+        setError(null);
+        setTurns(turnsFromStored(detail.turns));
+        setConversationId(id);
+        setShowHistory(false);
+    }, []);
     const lastTurn = turns.at(-1);
     const isAnswering = isBusy && lastTurn?.role === "assistant";
     const rendered = useMemo(() => turns.map((turn) => {
@@ -368,9 +413,34 @@ export function ConnectAskAi({ title = "Ask AI", assistantName = "Assistant", pl
         if (!text || isBusy)
             return;
         setInput("");
+        // Typing sends you back to the conversation: staying on the history list
+        // while an answer streams behind it would hide the thing just asked for.
+        setShowHistory(false);
         void send(text);
     };
-    return (_jsxs(_Fragment, { children: [!isOpen && (_jsx(Button, { isIconOnly: true, variant: "primary", "aria-label": title, onPress: () => setIsOpen(true), className: "fixed bottom-4 end-4 z-30 size-12 rounded-full shadow-lg sm:bottom-6 sm:end-6", children: _jsx(Sparkles, { className: "size-5" }) })), _jsx("div", { className: `fixed inset-0 z-40 bg-backdrop transition-opacity lg:hidden ${isOpen ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`, onClick: () => setIsOpen(false), "aria-hidden": "true" }), _jsx("aside", { "aria-hidden": !isOpen, className: `fixed inset-y-0 end-0 z-50 flex flex-col border-s border-border bg-surface shadow-xl transition-transform duration-300 ease-in-out ${panelShellWidth(isOpen)} ${isOpen ? "translate-x-0" : "translate-x-full rtl:-translate-x-full"} lg:static lg:z-auto lg:translate-x-0 lg:shadow-none lg:transition-[width]`, children: _jsxs("div", { className: `flex h-full shrink-0 flex-col ${PANEL_WIDTH}`, children: [_jsxs("div", { className: "flex items-center gap-2 border-b border-border px-4 py-3", children: [_jsx(Sparkles, { className: "size-4 shrink-0 text-accent" }), _jsx("span", { className: "flex-1 text-sm font-semibold", children: title }), _jsx(Button, { isIconOnly: true, size: "sm", variant: "tertiary", "aria-label": "Close", onPress: () => setIsOpen(false), children: _jsx(X, { className: "size-4" }) })] }), _jsxs("div", { className: "flex-1 space-y-3 overflow-y-auto p-4", children: [turns.length === 0 && (_jsxs("div", { className: "space-y-3", children: [_jsx("p", { className: "text-sm text-muted", children: hint }), currentScreen?.suggestions?.length ? (_jsx("div", { className: "flex flex-wrap gap-1.5", children: currentScreen.suggestions.map((suggestion) => (_jsx(Button, { size: "sm", variant: "secondary", className: "h-auto rounded-full px-2.5 py-1 text-start text-xs whitespace-normal", isDisabled: isBusy, onPress: () => void send(suggestion), children: suggestion }, suggestion))) })) : null] })), rendered, isBusy && lastTurn?.role === "user" && (_jsxs("div", { className: "rounded-md border border-border bg-accent/5 p-2.5 text-sm", children: [_jsx("p", { className: "mb-1 text-[11px] font-semibold tracking-wide text-muted uppercase", children: assistantName }), _jsx(ThinkingShimmer, {})] })), error && _jsx("p", { className: "text-xs text-danger", children: error }), _jsx("div", { ref: bottomRef })] }), _jsxs("form", { onSubmit: handleSubmit, className: "flex gap-2 border-t border-border p-3", children: [_jsxs(TextField, { variant: "secondary", className: "flex-1", children: [_jsx(Label, { className: "sr-only", children: placeholder }), _jsx(Input, { placeholder: placeholder, value: input, onChange: (event) => setInput(event.currentTarget.value), disabled: isBusy })] }), isBusy ? (_jsx(Button, { type: "button", isIconOnly: true, variant: "secondary", "aria-label": "Stop generating", onPress: stop, children: _jsx(Square, { className: "size-3.5" }) })) : (_jsx(Button, { type: "submit", isIconOnly: true, variant: "primary", "aria-label": "Send", isDisabled: !input.trim(), children: _jsx(Send, { className: "size-3.5" }) }))] })] }) })] }));
+    return (_jsxs(_Fragment, { children: [!isOpen && (_jsx(Button, { isIconOnly: true, variant: "primary", "aria-label": title, onPress: () => setIsOpen(true), className: "fixed bottom-4 end-4 z-30 size-12 rounded-full shadow-lg sm:bottom-6 sm:end-6", children: _jsx(Sparkles, { className: "size-5" }) })), _jsx("div", { className: `fixed inset-0 z-40 bg-backdrop transition-opacity lg:hidden ${isOpen ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`, onClick: () => setIsOpen(false), "aria-hidden": "true" }), _jsx("aside", { "aria-hidden": !isOpen, className: `fixed inset-y-0 end-0 z-50 flex flex-col border-s border-border bg-surface shadow-xl transition-transform duration-300 ease-in-out ${panelShellWidth(isOpen)} ${isOpen ? "translate-x-0" : "translate-x-full rtl:-translate-x-full"} lg:static lg:z-auto lg:translate-x-0 lg:shadow-none lg:transition-[width]`, children: _jsxs("div", { className: `flex h-full shrink-0 flex-col ${PANEL_WIDTH}`, children: [_jsxs("div", { className: "flex items-center gap-2 border-b border-border px-4 py-3", children: [_jsx(Sparkles, { className: "size-4 shrink-0 text-accent" }), _jsx("span", { className: "flex-1 text-sm font-semibold", children: title }), _jsx(Button, { isIconOnly: true, size: "sm", variant: "tertiary", "aria-label": "New conversation", 
+                                    // Disabled on an empty one rather than hidden: a control that
+                                    // appears and disappears as you use the panel is harder to find
+                                    // than one that is always in the same place.
+                                    isDisabled: turns.length === 0, onPress: startNewConversation, children: _jsx(Plus, { className: "size-4" }) }), _jsx(Button, { isIconOnly: true, size: "sm", variant: "tertiary", "aria-label": showHistory ? "Hide past conversations" : "Past conversations", "aria-pressed": showHistory, onPress: () => setShowHistory((open) => !open), children: _jsx(History, { className: "size-4" }) }), _jsx(Button, { isIconOnly: true, size: "sm", variant: "tertiary", "aria-label": "Close", onPress: () => setIsOpen(false), children: _jsx(X, { className: "size-4" }) })] }), showHistory ? (_jsx("div", { className: "min-h-0 flex-1 overflow-y-auto", children: _jsx(AskAiHistory, { refreshKey: writeCount, activeConversationId: conversationId, onOpenConversation: openConversation }) })) : (_jsxs("div", { className: "flex-1 space-y-3 overflow-y-auto p-4", children: [turns.length === 0 && (_jsxs("div", { className: "space-y-3", children: [_jsx("p", { className: "text-sm text-muted", children: hint }), currentScreen?.suggestions?.length ? (_jsx("div", { className: "flex flex-wrap gap-1.5", children: currentScreen.suggestions.map((suggestion) => (_jsx(Button, { size: "sm", variant: "secondary", className: "h-auto rounded-full px-2.5 py-1 text-start text-xs whitespace-normal", isDisabled: isBusy, onPress: () => void send(suggestion), children: suggestion }, suggestion))) })) : null] })), rendered, isBusy && lastTurn?.role === "user" && (_jsxs("div", { className: "rounded-md border border-border bg-accent/5 p-2.5 text-sm", children: [_jsx("p", { className: "mb-1 text-[11px] font-semibold tracking-wide text-muted uppercase", children: assistantName }), _jsx(ThinkingShimmer, {})] })), error && _jsx("p", { className: "text-xs text-danger", children: error }), _jsx("div", { ref: bottomRef })] })), _jsxs("form", { onSubmit: handleSubmit, className: "flex gap-2 border-t border-border p-3", children: [_jsxs(TextField, { variant: "secondary", className: "flex-1", children: [_jsx(Label, { className: "sr-only", children: placeholder }), _jsx(Input, { placeholder: placeholder, value: input, onChange: (event) => setInput(event.currentTarget.value), disabled: isBusy })] }), isBusy ? (_jsx(Button, { type: "button", isIconOnly: true, variant: "secondary", "aria-label": "Stop generating", onPress: stop, children: _jsx(Square, { className: "size-3.5" }) })) : (_jsx(Button, { type: "submit", isIconOnly: true, variant: "primary", "aria-label": "Send", isDisabled: !input.trim(), children: _jsx(Send, { className: "size-3.5" }) }))] })] }) })] }));
 }
 /** Hoisted for the same reference-equality reason as `ANIMATED` - Streamdown compares it by identity. */
 const LINK_SAFETY = { enabled: false };
+/**
+ * A fresh conversation id.
+ *
+ * `crypto.randomUUID` where it exists, and it usually does - but it is gated on
+ * a *secure context*, so it is simply absent on an `http://` origin that is not
+ * localhost. That is somebody's LAN dev server or a staging box on a bare IP,
+ * and a panel that throws there rather than chatting would be a poor trade for
+ * four lines. The fallback is not cryptographically strong and does not need to
+ * be: the id selects among the caller's own conversations and grants nothing -
+ * Connect refuses one belonging to another user or another application - so its
+ * only real job is not to collide with itself.
+ */
+function newConversationId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return `c-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}

package/dist/esm/client/provider.js

@@ -89,9 +89,9 @@ export function ConnectProvider({ clientId = "", basePath = "/api/connect", redi
         cache.current.set(key, pending);
         return pending;
     }, [basePath, fetchImpl]);
-    const mutateResource = useCallback(async (path, body) => {
+    const mutateResource = useCallback(async (path, body, method = "POST") => {
         const response = await (fetchImpl ?? globalThis.fetch)(`${basePath}${path}`, {
-            method: "POST",
+            method,
             credentials: "same-origin",
             headers: {
                 accept: "application/json",

package/dist/esm/server/client.js

@@ -8,6 +8,7 @@ import { SchedulingResource } from "./resources/scheduling.js";
 import { ContactsResource } from "./resources/contacts.js";
 import { ChannelsResource } from "./resources/channels.js";
 import { CallsResource } from "./resources/calls.js";
+import { ConversationsResource } from "./resources/conversations.js";
 import { KvResource } from "./resources/kv.js";
 import { BillingResource } from "./resources/billing.js";
 import { DriveResource } from "./resources/drive.js";
@@ -89,6 +90,8 @@ export class ConnectClient {
     channels;
     /** The calls that arrived on those channels, with their transcripts. */
     calls;
+    /** The message threads a subscribing workspace's agents are holding. */
+    conversations;
     /** RAG chat and structured extraction. */
     ai;
     enrichment;
@@ -142,6 +145,7 @@ export class ConnectClient {
         this.contacts = new ContactsResource(transport);
         this.channels = new ChannelsResource(transport);
         this.calls = new CallsResource(transport);
+        this.conversations = new ConversationsResource(transport);
         this.ai = new AiResource(transport);
         this.enrichment = new EnrichmentResource(transport);
         this.data = new DataResource(transport);
@@ -157,4 +161,4 @@ export class ConnectClient {
     }
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export const SDK_VERSION = "0.28.0";
+export const SDK_VERSION = "0.30.0";

package/dist/esm/server/handler.js

@@ -388,6 +388,12 @@ export function createConnectHandler(options) {
                 // decision, so there is nothing for this layer to check more strictly.
                 screenContext: body.screenContext,
                 screens: body.screens,
+                // The browser's own id for this conversation, so the turn is stored
+                // and can be reopened. Safe to relay: it decides *which* of the
+                // caller's own conversations is written to, never whose - Connect
+                // refuses an id belonging to another user or another application, and
+                // the owner comes from `asUser` below.
+                ...(typeof body.conversationId === "string" ? { conversationId: body.conversationId } : {}),
                 // Connect re-derives the workspace from this token, so the line above
                 // is belt to its braces - the browser cannot reach another tenant's
                 // Context Index even if this route were changed to trust the request.
@@ -406,6 +412,75 @@ export function createConnectHandler(options) {
                 },
             });
         },
+        /**
+         * Ask AI history - the list, one transcript, and a deletion.
+         *
+         * The same rule as every other route: the user comes from the caller's own
+         * session, forwarded as `asUser`, and Connect reads both the person and
+         * the workspace from it. Nothing here takes an owner from the request, so
+         * a browser cannot page through anybody else's conversations - which
+         * matters more here than on most routes, because a transcript is the most
+         * candid record this API holds of what somebody was trying to do.
+         *
+         * The id is the only thing a browser supplies. It selects among the
+         * caller's own conversations and nothing more: an id belonging to another
+         * user is a 404, and one belonging to another application the same, so a
+         * shared workspace's two products cannot read each other's.
+         *
+         * It travels as `?id=` rather than as a path segment, and the store routes
+         * are why. This table is keyed by an exact `METHOD /path` string; the only
+         * thing that matches a *prefix* is `isStoreRoute`, kept to a closed list
+         * precisely so the bridge cannot drift into a generic proxy. Widening that
+         * matcher for one more resource would be the first step of exactly that
+         * drift, so the id goes in the query and the route keys stay exact.
+         *
+         * `requireToken` rather than `requireWorkspace`: Connect resolves the
+         * workspace from the token itself and refuses a staff session there, so
+         * the extra identity round trip would buy a differently-worded 403 and
+         * nothing else.
+         */
+        "GET /ai/conversations": async (request) => {
+            const url = new URL(request.url);
+            const limit = url.searchParams.get("limit");
+            const cursor = url.searchParams.get("cursor");
+            return json(await client.ai.listConversations({
+                asUser: await requireToken(request),
+                // Forwarded only when present, so Connect's own defaults apply
+                // rather than this layer inventing a second set of them.
+                ...(limit !== null ? { limit: Number(limit) } : {}),
+                ...(cursor ? { cursor } : {}),
+            }));
+        },
+        "GET /ai/conversation": async (request) => {
+            const conversationId = new URL(request.url).searchParams.get("id");
+            if (!conversationId) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "id is required",
+                    endpoint: "GET /ai/conversation",
+                });
+            }
+            return json(await client.ai.getConversation({
+                conversationId,
+                asUser: await requireToken(request),
+            }));
+        },
+        "DELETE /ai/conversation": async (request) => {
+            const conversationId = new URL(request.url).searchParams.get("id");
+            if (!conversationId) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "id is required",
+                    endpoint: "DELETE /ai/conversation",
+                });
+            }
+            return json(await client.ai.deleteConversation({
+                conversationId,
+                asUser: await requireToken(request),
+            }));
+        },
         /**
          * The store, forwarded.
          *