@blocksdiy/react-common 1.39.0 → 1.41.0

package/dist/components/new-agent-chat.d.ts

@@ -114,6 +114,13 @@ export interface AgentChatRootProps {
      * between an app that can draw these pauses and one that cannot.
      */
     supportsServerInterrupt?: boolean;
+    /**
+     * Fires once a user send has been added to the conversation, with its text (empty
+     * string for attachment-only sends) — the seam for ChatGPT-style optimistic thread
+     * listing: hosts pair it with useAgentThreads' notifyThreadActivity. Covers sends
+     * routed through `sendMessage`, not the auto-sent `initialPrompt`.
+     */
+    onUserMessageSent?: (text: string) => void;
 }
 export declare const AgentChatRoot: ({ ...props }: AgentChatRootProps) => import("react").JSX.Element | null;
 export interface AgentChatMessageProps {

package/dist/components/new-agent-chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"new-agent-chat.d.ts","sourceRoot":"","sources":["../../src/components/new-agent-chat.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"new-agent-chat.d.ts","sourceRoot":"","sources":["../../src/components/new-agent-chat.tsx"],"names":[],"mappings":"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"}

package/dist/components/new-agent-chat.js

@@ -242,7 +242,7 @@ const SessionReadables = () => {
     // });
     return null;
 };
-const ChatInitializer = ({ agentBlock, agentChatBlock, chatId, token, appId, components, currentThreadId, setCurrentThreadId, children, }) => {
+const ChatInitializer = ({ agentBlock, agentChatBlock, chatId, token, appId, components, currentThreadId, setCurrentThreadId, children, onUserMessageSent, }) => {
     const [agentChat, setAgentChat] = useState(null);
     const [agent, setAgent] = useState(null);
     // `isConfigLoaded` covers the (small, parallel) async fetch of the
@@ -313,9 +313,9 @@ const ChatInitializer = ({ agentBlock, agentChatBlock, chatId, token, appId, com
     // prop only feeds React context, but `agent.threadId` is what hits the
     // wire and the LangGraph checkpoint. `<CopilotChat>` does this for you;
     // we use the headless hook so we do it ourselves. Layout-effect timing
-    // is required to beat the library's connect-on-mount effect.
-    // Limitation: doesn't abort an in-flight run on thread-id swap — fine
-    // because `currentThreadId` is effectively immutable today.
+    // is required to beat the library's connect-on-mount/on-swap effect.
+    // A swap doesn't abort an in-flight run — the connect effect's cleanup
+    // detaches it client-side, and the run completes server-side as usual.
     useIsomorphicLayoutEffect(() => {
         if (copilotAgent && currentThreadId) {
             copilotAgent.threadId = currentThreadId;
@@ -326,13 +326,75 @@ const ChatInitializer = ({ agentBlock, agentChatBlock, chatId, token, appId, com
     }, [copilotAgent, currentThreadId]);
     const [prompt, setPrompt] = useState("");
     const [attachments, setAttachments] = useState([]);
+    // Conversation identity. When a mounted chat is pointed at another conversation, the
+    // reconnect replay takes a round-trip — clear the previous transcript and composer
+    // immediately so the old conversation never lingers on screen (same visual contract as
+    // a remount). Deliberately NOT keyed on `initKey`: that also changes when the block
+    // configs finish loading, and clearing then would wipe a freshly replayed transcript.
+    const conversationKey = `${chatId ?? ""}|${currentThreadId ?? ""}`;
+    const prevConversationKeyRef = useRef(conversationKey);
+    useIsomorphicLayoutEffect(() => {
+        if (prevConversationKeyRef.current === conversationKey) {
+            return;
+        }
+        prevConversationKeyRef.current = conversationKey;
+        copilotAgent?.setMessages?.([]);
+        setPrompt("");
+        setAttachments([]);
+        // The clear above runs in the layout phase, but the previous conversation's run is
+        // detached in passive effects — and even past detach, events already buffered in the
+        // apply pipeline keep applying, each reassigning `agent.messages` WHOLESALE. One late
+        // chunk would resurrect the entire previous transcript (and re-arm its auto-executing
+        // tool-call follow-ups) under the new conversation's header. Detach here too and
+        // re-clear once the drain settles; the reconnect that follows replays on top of the
+        // (guaranteed-empty) mirror. On threadId switches the core's fresh-restore re-clears
+        // as well — harmless overlap — but on chatId-only switches this is the only re-clear.
+        const detachable = copilotAgent;
+        const drained = detachable?.detachActiveRun?.();
+        if (drained) {
+            const clearedForKey = conversationKey;
+            void drained.then(() => {
+                if (prevConversationKeyRef.current === clearedForKey) {
+                    copilotAgent?.setMessages?.([]);
+                }
+            });
+        }
+    }, [conversationKey]);
+    // CopilotKit reconnects only when its threadId changes — but a conversation is the
+    // (chatId, threadId) PAIR, and rows written by surfaces that use the fixed default
+    // thread id differ only by chatId. On such a chatId-only switch the library's connect
+    // effect sees unchanged deps and does nothing, which would leave the (just cleared)
+    // transcript empty forever. Reconnect manually, replicating the core's fresh-restore
+    // steps: reset state and drop the replay cursor — cursors are keyed by threadId, so
+    // the shared id makes the previous conversation's cursor actively wrong here — then
+    // connect (the core detaches any in-flight run itself). The core reads `properties`
+    // after an await, so the new chatId is already synced by the time the request builds.
+    const prevConnectionRef = useRef({ chatId, threadId: currentThreadId });
+    useEffect(() => {
+        const previous = prevConnectionRef.current;
+        prevConnectionRef.current = { chatId, threadId: currentThreadId };
+        const chatIdChanged = previous.chatId !== chatId;
+        const threadIdChanged = previous.threadId !== currentThreadId;
+        if (!copilotAgent || !chatIdChanged || threadIdChanged) {
+            return;
+        }
+        copilotAgent.setState?.({});
+        copilotAgent.clearReplayCursor?.(currentThreadId);
+        // Same guard convention as the composer send path: a failed reconnect already
+        // surfaces through the availability state; the rejection carries no extra signal.
+        void copilotkit.connectAgent({ agent: copilotAgent }).catch(() => undefined);
+    }, [chatId, currentThreadId, copilotAgent, copilotkit]);
     const [isDraggingFiles, setIsDraggingFiles] = useState(false);
     const attachmentsEnabled = agentChat ? agentChat.disableAttachments !== true : false;
     const canSendMessage = Boolean(agentChatBlock && agentChat && agent && isConfigLoaded && isAgentReady && !isAgentRunning);
     const isFetchingMessages = !isConfigLoaded || (!isAgentReady && copilotMessages.length === 0);
-    // CopilotKit reports `isLoading` during connect/replay as well as real runs.
-    // Only expose thinking once the bootstrap connect phase has completed.
-    const isThinking = isAgentRunning && !isFetchingMessages;
+    // CopilotKit reports `isLoading` during connect/replay as well as real runs. Only expose
+    // thinking once the bootstrap connect phase has completed — and that needs the readiness
+    // latch, not just `isFetchingMessages`, which goes false as soon as ONE replayed message
+    // exists: without `isAgentReady`, thinking leaks true for the tail of every replay, and
+    // every load or thread switch flashes the typing dots under the transcript. Real runs are
+    // unaffected — sending requires readiness (canSendMessage), so the latch is already set.
+    const isThinking = isAgentRunning && !isFetchingMessages && isAgentReady;
     const runAgentWithRetry = useCallback(async (agentToRun, messageCountAtRunStart, forwardedProps) => {
         if (agentToRun.isRunning) {
             return false;
@@ -376,8 +438,20 @@ const ChatInitializer = ({ agentBlock, agentChatBlock, chatId, token, appId, com
             return;
         }
         copilotAgent.addMessage({ ...message, id: generateId(), role: "user" });
+        // The send seam, fired once the message is IN the conversation, so hosts can react
+        // to it (e.g. list the thread optimistically). Covers every send routed through
+        // `sendMessage` — composer, empty-state heroes, user-generated chat components —
+        // but deliberately NOT the auto-sent `initialPrompt` below, whose hidden variant is
+        // a primer rather than something the user wrote.
+        if (onUserMessageSent) {
+            const { content } = message;
+            const textPart = Array.isArray(content)
+                ? content.find((part) => part.type === "text")
+                : undefined;
+            onUserMessageSent(typeof content === "string" ? content : (textPart?.text ?? ""));
+        }
         await runAgentWithRetry(copilotAgent, copilotAgent.messages.length);
-    }, [canSendMessage, copilotAgent, runAgentWithRetry]);
+    }, [canSendMessage, copilotAgent, runAgentWithRetry, onUserMessageSent]);
     // Not sourced from `useInterrupt`: that hook only hands `resolve` to its own
     // `render`, which it skips whenever nothing is pending — so after a reload there
     // is no way to obtain it. `runAgentWithRetry`'s `isRunning` guard makes a
@@ -701,6 +775,18 @@ export const AgentChatRoot = ({ ...props
         ...(appId ? { "x-app-id": appId } : {}),
     }), [token, socketId, appId]);
     const [currentThreadId, setCurrentThreadId] = useState(() => defaultThreadId ?? (noPersistency ? crypto.randomUUID() : DEFAULT_CHAT_THREAD_ID));
+    // Follow later `defaultThreadId` changes — a mounted chat can be pointed at another
+    // conversation (the agent inbox switches threads without remounting). Adjusted during
+    // render (the React derived-state pattern) so children commit with the new thread and
+    // the new chatId prop atomically; the headless connect effect keys on the configuration
+    // threadId and replays the new transcript. Static-prop consumers never hit this branch.
+    const [prevDefaultThreadId, setPrevDefaultThreadId] = useState(defaultThreadId);
+    if (defaultThreadId !== prevDefaultThreadId) {
+        setPrevDefaultThreadId(defaultThreadId);
+        if (defaultThreadId && defaultThreadId !== currentThreadId) {
+            setCurrentThreadId(defaultThreadId);
+        }
+    }
     const blocksApiService = useMemo(() => new BlocksApiService({ token }), [token]);
     const [agentChatBlock, setAgentChatBlock] = useState(null);
     const [agentBlock, setAgentBlock] = useState(null);
@@ -798,7 +884,7 @@ export const AgentChatRoot = ({ ...props
         }, 
         // Explicit false: when undefined, CopilotKit auto-enables its inspector
         // devtools on localhost hostnames.
-        enableInspector: false, children: [_jsx(SessionReadables, {}), _jsx(ChatInitializer, { agentBlock: agentBlock, agentChatBlock: agentChatBlock, chatId: chatId, noPersistency: noPersistency, token: token, appId: appId, components: components, currentThreadId: currentThreadId, setCurrentThreadId: setCurrentThreadId, children: children })] }));
+        enableInspector: false, children: [_jsx(SessionReadables, {}), _jsx(ChatInitializer, { agentBlock: agentBlock, agentChatBlock: agentChatBlock, chatId: chatId, noPersistency: noPersistency, token: token, appId: appId, components: components, currentThreadId: currentThreadId, setCurrentThreadId: setCurrentThreadId, onUserMessageSent: props.onUserMessageSent, children: children })] }));
 };
 export function AgentChatMessage({ message, index, ...props }) {
     if (message.role === "user" && message.name === HIDDEN_INITIAL_PROMPT_MESSAGE_NAME) {

package/dist/hooks/agent-thread-live-update.d.ts

@@ -0,0 +1,72 @@
+export type AgentThreadStatus = "idle" | "interrupted" | "error";
+export type AgentThreadSource = "direct_chat" | "agent_call" | "send_message" | "unknown";
+export interface AgentThreadItem {
+    agentId: string | null;
+    /** Never null — pass back verbatim to open the conversation. */
+    chatId: string;
+    /** Never null — pass back verbatim to open the conversation. */
+    chatThreadId: string;
+    source: AgentThreadSource;
+    status: AgentThreadStatus;
+    title: string | null;
+    turnCount: number;
+    /** First seen by the index — NOT thread creation time. */
+    firstSeenAt: string;
+    lastActivityAt: string;
+}
+/** The (chatId, chatThreadId) pair — the only stable identity of a thread row. */
+export declare const agentThreadKey: (thread: Pick<AgentThreadItem, "chatId" | "chatThreadId">) => string;
+/**
+ * Whether a realtime payload's `thread` is a complete list-item row. The server
+ * serializes the exact item shape into every event, so this normally passes; when
+ * it doesn't (contract drift), the consumer falls back to the getOne endpoint.
+ */
+export declare const isAgentThreadItem: (value: unknown) => value is AgentThreadItem;
+/**
+ * Provisional row title from the prompt that started a conversation (ChatGPT-style):
+ * one line, whitespace collapsed, capped like the server's generated titles. Null when
+ * there's nothing usable (attachment-only sends) — the UI keeps its id-based fallback.
+ */
+export declare const provisionalThreadTitle: (prompt: string | undefined) => string | null;
+export interface AgentThreadLiveUpdateOptions {
+    /** Active server-side filters — an updated row that stops matching leaves the list. */
+    status?: AgentThreadStatus;
+    source?: AgentThreadSource;
+    chatId?: string;
+    /** Active sort, mirroring the endpoint's defaults (lastActivity, desc). */
+    sort?: "lastActivity" | "firstSeen";
+    order?: "asc" | "desc";
+    /** True when more pages exist server-side beyond the loaded window. */
+    hasMore?: boolean;
+}
+/**
+ * Merge one realtime thread update into a loaded list. Pure; returns the input array
+ * untouched when the event is stale, filtered out, or out of the loaded window.
+ *
+ * - Out-of-order delivery can't regress a row: events older than the loaded row (by
+ *   lastActivityAt) are dropped — checked FIRST, so a stale event can't evict a
+ *   still-current row through the filter check below either. Renames keep
+ *   lastActivityAt, so equal passes.
+ * - A row that stops matching the active filters is removed; a matching one is upserted
+ *   and the list re-sorted by the active sort (stable, so ties keep their server order).
+ * - A NEW row sorting past every loaded row while more pages exist may belong beyond the
+ *   loaded window; it's skipped so the list stays contiguous with the pagination cursor
+ *   (unreachable under the default lastActivity-desc sort, where fresh activity sorts first).
+ */
+/** Whether a row passes the list's active server-side filters. */
+export declare const matchesAgentThreadFilters: (item: AgentThreadItem, options?: AgentThreadLiveUpdateOptions) => boolean;
+export declare const applyAgentThreadUpdate: (threads: AgentThreadItem[], incoming: AgentThreadItem, options?: AgentThreadLiveUpdateOptions) => AgentThreadItem[];
+/**
+ * Overlay optimistic rows (conversations the user just acted on, ChatGPT-style) onto the
+ * loaded list. Each row goes through the same merge as a realtime event, so filters and
+ * sorting apply — except that a server row still untitled borrows the optimistic
+ * (prompt-derived) title until the generated one lands. Pure; returns `threads` untouched
+ * when nothing changes.
+ *
+ * An entry steps aside once the loaded row has recorded MORE turns than it did: turnCount
+ * is server-monotonic, so the handover can't be held off by a client clock running ahead
+ * of the server (the entry's lastActivityAt is stamped locally, and the merge's staleness
+ * guard compares it against server timestamps).
+ */
+export declare const overlayOptimisticThreads: (threads: AgentThreadItem[], optimistic: ReadonlyMap<string, AgentThreadItem>, options?: AgentThreadLiveUpdateOptions) => AgentThreadItem[];
+//# sourceMappingURL=agent-thread-live-update.d.ts.map

package/dist/hooks/agent-thread-live-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-thread-live-update.d.ts","sourceRoot":"","sources":["../../src/hooks/agent-thread-live-update.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,aAAa,GAAG,OAAO,CAAC;AAEjE,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,YAAY,GAAG,cAAc,GAAG,SAAS,CAAC;AAE1F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,kFAAkF;AAClF,eAAO,MAAM,cAAc,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,CAAC,KAAG,MAC9C,CAAC;AAK7C;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAiB3D,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,IAQ5E,CAAC;AAEF,MAAM,WAAW,4BAA4B;IAC3C,uFAAuF;IACvF,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,IAAI,CAAC,EAAE,cAAc,GAAG,WAAW,CAAC;IACpC,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAOD;;;;;;;;;;;;;GAaG;AACH,kEAAkE;AAClE,eAAO,MAAM,yBAAyB,GAAI,MAAM,eAAe,EAAE,UAAS,4BAAiC,KAAG,OAGzD,CAAC;AAEtD,eAAO,MAAM,sBAAsB,GACjC,SAAS,eAAe,EAAE,EAC1B,UAAU,eAAe,EACzB,UAAS,4BAAiC,KACzC,eAAe,EAqBjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,eAAe,EAAE,EAC1B,YAAY,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAChD,UAAS,4BAAiC,KACzC,eAAe,EAkBjB,CAAC"}

package/dist/hooks/agent-thread-live-update.js

@@ -0,0 +1,115 @@
+// Wire types and pure merge logic for the agent-threads index and its realtime
+// AGENT_THREAD_UPDATED events. Dependency-free on purpose: use-agent-threads
+// re-exports everything here, and node tests load this module directly.
+/** The (chatId, chatThreadId) pair — the only stable identity of a thread row. */
+export const agentThreadKey = (thread) => `${thread.chatId}::${thread.chatThreadId}`;
+const THREAD_STATUSES = ["idle", "interrupted", "error"];
+const THREAD_SOURCES = ["direct_chat", "agent_call", "send_message", "unknown"];
+/**
+ * Whether a realtime payload's `thread` is a complete list-item row. The server
+ * serializes the exact item shape into every event, so this normally passes; when
+ * it doesn't (contract drift), the consumer falls back to the getOne endpoint.
+ */
+export const isAgentThreadItem = (value) => {
+    const item = value;
+    return (typeof item === "object" &&
+        item !== null &&
+        (typeof item.agentId === "string" || item.agentId === null) &&
+        typeof item.chatId === "string" &&
+        item.chatId.length > 0 &&
+        typeof item.chatThreadId === "string" &&
+        item.chatThreadId.length > 0 &&
+        THREAD_SOURCES.includes(item.source) &&
+        THREAD_STATUSES.includes(item.status) &&
+        (typeof item.title === "string" || item.title === null) &&
+        typeof item.turnCount === "number" &&
+        typeof item.firstSeenAt === "string" &&
+        typeof item.lastActivityAt === "string");
+};
+// Matches the server's cap for LLM-generated titles (wf-actions-py TITLE_MAX_CHARS).
+const PROVISIONAL_TITLE_MAX_CHARS = 80;
+/**
+ * Provisional row title from the prompt that started a conversation (ChatGPT-style):
+ * one line, whitespace collapsed, capped like the server's generated titles. Null when
+ * there's nothing usable (attachment-only sends) — the UI keeps its id-based fallback.
+ */
+export const provisionalThreadTitle = (prompt) => {
+    const collapsed = prompt?.replace(/\s+/g, " ").trim();
+    if (!collapsed) {
+        return null;
+    }
+    return collapsed.length > PROVISIONAL_TITLE_MAX_CHARS
+        ? `${collapsed.slice(0, PROVISIONAL_TITLE_MAX_CHARS - 1).trimEnd()}…`
+        : collapsed;
+};
+const sortTime = (item, sort) => {
+    const parsed = new Date(sort === "firstSeen" ? item.firstSeenAt : item.lastActivityAt).getTime();
+    return Number.isNaN(parsed) ? 0 : parsed;
+};
+/**
+ * Merge one realtime thread update into a loaded list. Pure; returns the input array
+ * untouched when the event is stale, filtered out, or out of the loaded window.
+ *
+ * - Out-of-order delivery can't regress a row: events older than the loaded row (by
+ *   lastActivityAt) are dropped — checked FIRST, so a stale event can't evict a
+ *   still-current row through the filter check below either. Renames keep
+ *   lastActivityAt, so equal passes.
+ * - A row that stops matching the active filters is removed; a matching one is upserted
+ *   and the list re-sorted by the active sort (stable, so ties keep their server order).
+ * - A NEW row sorting past every loaded row while more pages exist may belong beyond the
+ *   loaded window; it's skipped so the list stays contiguous with the pagination cursor
+ *   (unreachable under the default lastActivity-desc sort, where fresh activity sorts first).
+ */
+/** Whether a row passes the list's active server-side filters. */
+export const matchesAgentThreadFilters = (item, options = {}) => (!options.status || item.status === options.status) &&
+    (!options.source || item.source === options.source) &&
+    (!options.chatId || item.chatId === options.chatId);
+export const applyAgentThreadUpdate = (threads, incoming, options = {}) => {
+    const key = agentThreadKey(incoming);
+    const existing = threads.find((thread) => agentThreadKey(thread) === key);
+    if (existing && sortTime(incoming, "lastActivity") < sortTime(existing, "lastActivity")) {
+        return threads;
+    }
+    if (!matchesAgentThreadFilters(incoming, options)) {
+        return existing ? threads.filter((thread) => thread !== existing) : threads;
+    }
+    const sort = options.sort ?? "lastActivity";
+    const direction = options.order === "asc" ? 1 : -1;
+    const next = existing ? threads.map((thread) => (thread === existing ? incoming : thread)) : [...threads, incoming];
+    next.sort((a, b) => direction * (sortTime(a, sort) - sortTime(b, sort)));
+    if (!existing && options.hasMore && threads.length > 0 && next[next.length - 1] === incoming) {
+        return threads;
+    }
+    return next;
+};
+/**
+ * Overlay optimistic rows (conversations the user just acted on, ChatGPT-style) onto the
+ * loaded list. Each row goes through the same merge as a realtime event, so filters and
+ * sorting apply — except that a server row still untitled borrows the optimistic
+ * (prompt-derived) title until the generated one lands. Pure; returns `threads` untouched
+ * when nothing changes.
+ *
+ * An entry steps aside once the loaded row has recorded MORE turns than it did: turnCount
+ * is server-monotonic, so the handover can't be held off by a client clock running ahead
+ * of the server (the entry's lastActivityAt is stamped locally, and the merge's staleness
+ * guard compares it against server timestamps).
+ */
+export const overlayOptimisticThreads = (threads, optimistic, options = {}) => {
+    if (optimistic.size === 0) {
+        return threads;
+    }
+    let merged = threads;
+    for (const [key, row] of optimistic) {
+        const handedOver = threads.some((thread) => agentThreadKey(thread) === key && thread.turnCount > row.turnCount);
+        if (!handedOver) {
+            merged = applyAgentThreadUpdate(merged, row, options);
+        }
+    }
+    if (!merged.some((row) => row.title === null && optimistic.get(agentThreadKey(row))?.title)) {
+        return merged;
+    }
+    return merged.map((row) => {
+        const provisional = row.title === null ? optimistic.get(agentThreadKey(row))?.title : null;
+        return provisional ? { ...row, title: provisional } : row;
+    });
+};

package/dist/hooks/use-agent-threads.d.ts

@@ -0,0 +1,97 @@
+import { type AgentThreadItem, type AgentThreadSource, type AgentThreadStatus } from "./agent-thread-live-update.js";
+export * from "./agent-thread-live-update.js";
+export interface AgentThreadsPage {
+    items: AgentThreadItem[];
+    nextCursor: string | null;
+}
+export interface UseAgentThreadsOptions {
+    agentId: string;
+    status?: AgentThreadStatus;
+    source?: AgentThreadSource;
+    chatId?: string;
+    limit?: number;
+    sort?: "lastActivity" | "firstSeen";
+    order?: "asc" | "desc";
+    /** Platform host override; defaults to getApiHost() (same convention as the agent chat). */
+    baseUrl?: string;
+    /** Bearer token for callers that don't share the platform session cookie. */
+    token?: string;
+    /** Extra request headers, merged over the defaults. */
+    headers?: Record<string, string>;
+}
+export interface UseAgentThreadsResult {
+    threads: AgentThreadItem[];
+    /**
+     * The thread the consumer is currently viewing — never null. When nothing is
+     * selected the hook auto-generates a draft with a fresh (chatId, chatThreadId)
+     * pair the chat surface can use verbatim; once the draft's first turn is indexed
+     * and the list refreshes, this resolves to that real row (same key) seamlessly.
+     * For selected threads it prefers the LIST's row for the same identity — so
+     * status/turnCount stay fresh after a refresh — falling back to the last set
+     * item when the row isn't in the loaded pages, so selection never vanishes.
+     */
+    currentThread: AgentThreadItem;
+    /** True while currentThread is an auto-generated draft not yet in the index. */
+    isDraftThread: boolean;
+    /** Move between threads; null mints a fresh draft ("new chat"). Resets when agentId changes. */
+    setCurrentThread: (thread: AgentThreadItem | null) => void;
+    /**
+     * Report a user send on the current conversation (pass the prompt text) — ChatGPT-style
+     * optimistic listing. A conversation with no server row yet appears in `threads`
+     * immediately, titled by the truncated prompt, and every send bumps the row's recency;
+     * server rows take over under the same identity as events land. Identity-stable — safe
+     * to hand to memoized chat surfaces (e.g. a chat root's onUserMessageSent).
+     */
+    notifyThreadActivity: (prompt?: string) => void;
+    /**
+     * Rename a conversation. Optimistic — the list shows the new title immediately and
+     * rolls back on failure (the promise rejects so callers can surface an error).
+     */
+    renameThread: (thread: Pick<AgentThreadItem, "chatId" | "chatThreadId">, title: string) => Promise<void>;
+    /** First page (or refresh) in flight. */
+    isLoading: boolean;
+    /** A cursor page is being appended. */
+    isLoadingMore: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    loadMore: () => Promise<void>;
+    /**
+     * Re-walk every loaded page. Freshness is otherwise live (the hook subscribes to
+     * AGENT_THREAD_UPDATED itself) — keep refresh for recovery, e.g. a throttled
+     * window-focus refresh after a dropped connection.
+     */
+    refresh: () => Promise<void>;
+}
+/**
+ * The platform inbox's fixed chatId for an agent: one shared value per agent block, so
+ * index rows are recognizable as "direct chats with this agent on the platform" at a
+ * glance (and filterable via the endpoint's chatId param). Conversations under it are
+ * distinguished by their unique chatThreadId.
+ */
+export declare const AGENT_INBOX_CHAT_PREFIX = "agent-inbox-";
+export declare const agentInboxChatId: (agentId: string) => string;
+/**
+ * Short human label for a row with no generated title yet: the half of the identity
+ * pair that varies for the row. Inbox rows share one fixed chatId (above) and vary by
+ * thread id; rows from other surfaces (published-app chats) are the reverse. One-sided
+ * writers (agent calls) index a "_" placeholder for the missing half — fall back to
+ * the real half rather than labeling every such row "_".
+ */
+export declare const agentThreadShortLabel: (thread: Pick<AgentThreadItem, "chatId" | "chatThreadId">) => string;
+/** How a row is labelled: its title, or the id-based short label while it has none. */
+export declare const agentThreadDisplayTitle: (thread: Pick<AgentThreadItem, "chatId" | "chatThreadId" | "title">) => string;
+/**
+ * Headless agent-threads index: fetches an agent's conversation threads from the platform
+ * endpoint with keyset-cursor pagination, then keeps them live — every threads-table write
+ * publishes AGENT_THREAD_UPDATED on the app's Pusher channel and the hook upserts the row,
+ * falling back to the getOne endpoint when a payload lacks the full row. New conversations
+ * list optimistically the moment the first prompt is sent (wire notifyThreadActivity to the
+ * chat's send seam). Data only — pair it with whatever list UI the host app uses. No
+ * per-host wiring: both hosts already run the shared websocketsService singleton and
+ * subscribe the app channel (the platform via its layouts' useWebsockets hooks, a
+ * boilerplate app via the client SDK's ClientProvider), and listening before the socket
+ * connects just parks the handler.
+ */
+export declare const useAgentThreads: (options: UseAgentThreadsOptions) => UseAgentThreadsResult;
+export default useAgentThreads;
+//# sourceMappingURL=use-agent-threads.d.ts.map

package/dist/hooks/use-agent-threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent-threads.d.ts","sourceRoot":"","sources":["../../src/hooks/use-agent-threads.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAMvB,MAAM,4BAA4B,CAAC;AAKpC,cAAc,4BAA4B,CAAC;AAO3C,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,cAAc,GAAG,WAAW,CAAC;IACpC,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,4FAA4F;IAC5F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B;;;;;;;;OAQG;IACH,aAAa,EAAE,eAAe,CAAC;IAC/B,gFAAgF;IAChF,aAAa,EAAE,OAAO,CAAC;IACvB,gGAAgG;IAChG,gBAAgB,EAAE,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IAC3D;;;;;;OAMG;IACH,oBAAoB,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzG,yCAAyC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B;;;;OAIG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAgD,CAAC;AAEpG;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,CAAC,KAAG,MAIhG,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,KAAG,MACpD,CAAC;AA8D1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB,KAAG,qBAsdjE,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/hooks/use-agent-threads.js

@@ -0,0 +1,510 @@
+import { getApiHost } from "@blocksdiy/blocks-client-api/envService";
+import { websocketsService } from "@blocksdiy/blocks-client-api/websocketService";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { agentThreadKey, applyAgentThreadUpdate, isAgentThreadItem, matchesAgentThreadFilters, overlayOptimisticThreads, provisionalThreadTitle, } from "./agent-thread-live-update.js";
+// Wire types, the identity key, and the realtime merge logic live in
+// ./agent-thread-live-update (dependency-free, unit-testable); re-exported so
+// consumers keep importing everything from this module.
+export * from "./agent-thread-live-update.js";
+/* public decouple - AGENT_THREAD_UPDATED rides AgentThreadEventPayload (packages/common
+   agent-thread-events.ts): the event's `thread` field is exactly the list/GET item shape,
+   relayed verbatim from wf-actions-py to the app's Pusher channel. */
+const AGENT_THREAD_UPDATED = "AGENT_THREAD_UPDATED";
+/**
+ * The platform inbox's fixed chatId for an agent: one shared value per agent block, so
+ * index rows are recognizable as "direct chats with this agent on the platform" at a
+ * glance (and filterable via the endpoint's chatId param). Conversations under it are
+ * distinguished by their unique chatThreadId.
+ */
+export const AGENT_INBOX_CHAT_PREFIX = "agent-inbox-";
+export const agentInboxChatId = (agentId) => `${AGENT_INBOX_CHAT_PREFIX}${agentId}`;
+/**
+ * Short human label for a row with no generated title yet: the half of the identity
+ * pair that varies for the row. Inbox rows share one fixed chatId (above) and vary by
+ * thread id; rows from other surfaces (published-app chats) are the reverse. One-sided
+ * writers (agent calls) index a "_" placeholder for the missing half — fall back to
+ * the real half rather than labeling every such row "_".
+ */
+export const agentThreadShortLabel = (thread) => {
+    const varying = thread.chatId.startsWith(AGENT_INBOX_CHAT_PREFIX) ? thread.chatThreadId : thread.chatId;
+    const other = varying === thread.chatId ? thread.chatThreadId : thread.chatId;
+    return (varying === "_" ? other : varying).slice(0, 8);
+};
+/** How a row is labelled: its title, or the id-based short label while it has none. */
+export const agentThreadDisplayTitle = (thread) => thread.title ?? `Chat ${agentThreadShortLabel(thread)}`;
+const buildQuery = (filters, cursor) => {
+    const params = new URLSearchParams();
+    if (filters.status) {
+        params.set("status", filters.status);
+    }
+    if (filters.source) {
+        params.set("source", filters.source);
+    }
+    if (filters.chatId) {
+        params.set("chatId", filters.chatId);
+    }
+    if (filters.limit) {
+        params.set("limit", String(filters.limit));
+    }
+    if (filters.sort) {
+        params.set("sort", filters.sort);
+    }
+    if (filters.order) {
+        params.set("order", filters.order);
+    }
+    if (cursor) {
+        params.set("cursor", cursor);
+    }
+    const query = params.toString();
+    return query ? `?${query}` : "";
+};
+const appendPage = (existing, page) => {
+    const seen = new Set(existing.map(agentThreadKey));
+    return [...existing, ...page.filter((thread) => !seen.has(agentThreadKey(thread)))];
+};
+/**
+ * A not-yet-indexed conversation. chatId is ALWAYS the agent's static inbox id (the
+ * surface marker — identical for every inbox conversation with this agent); only the
+ * thread id makes each conversation unique, and it must be a UUID — CopilotKit
+ * replaces non-UUID thread ids per load, which breaks history. Sharing the chatId
+ * also means inbox thread switches are pure thread-id changes, the chat stack's
+ * native reconnect path.
+ */
+const makeDraftThread = (agentId) => {
+    const now = new Date().toISOString();
+    return {
+        agentId: agentId || null,
+        chatId: agentInboxChatId(agentId),
+        chatThreadId: crypto.randomUUID(),
+        source: "direct_chat",
+        status: "idle",
+        title: null,
+        turnCount: 0,
+        firstSeenAt: now,
+        lastActivityAt: now,
+    };
+};
+/**
+ * Headless agent-threads index: fetches an agent's conversation threads from the platform
+ * endpoint with keyset-cursor pagination, then keeps them live — every threads-table write
+ * publishes AGENT_THREAD_UPDATED on the app's Pusher channel and the hook upserts the row,
+ * falling back to the getOne endpoint when a payload lacks the full row. New conversations
+ * list optimistically the moment the first prompt is sent (wire notifyThreadActivity to the
+ * chat's send seam). Data only — pair it with whatever list UI the host app uses. No
+ * per-host wiring: both hosts already run the shared websocketsService singleton and
+ * subscribe the app channel (the platform via its layouts' useWebsockets hooks, a
+ * boilerplate app via the client SDK's ClientProvider), and listening before the socket
+ * connects just parks the handler.
+ */
+export const useAgentThreads = (options) => {
+    const { agentId, status, source, chatId, limit, sort, order, baseUrl } = options;
+    const [threads, setThreads] = useState([]);
+    // Mirror of `threads` for reads outside render (a refresh needs the loaded count without
+    // re-closing over state). Every write goes through applyThreads so the two can't diverge;
+    // reads are race-free because writers are serialized (loadMore awaits any in-flight
+    // refresh, and every write re-checks the request sequence first).
+    const threadsRef = useRef([]);
+    const applyThreads = useCallback((items) => {
+        threadsRef.current = items;
+        setThreads(items);
+    }, []);
+    const [nextCursor, setNextCursor] = useState(null);
+    // Cursor mirror, same contract as threadsRef: loadMore reads it after awaiting an
+    // in-flight refresh, when its render-time closure value is stale by definition.
+    const nextCursorRef = useRef(null);
+    const applyCursor = useCallback((cursor) => {
+        nextCursorRef.current = cursor;
+        setNextCursor(cursor);
+    }, []);
+    // Starts true (when a fetch is coming): the first-page effect only runs AFTER the mount
+    // paint, so initializing false would flash the "no threads" empty state for a frame.
+    const [isLoading, setIsLoading] = useState(Boolean(agentId));
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const [selectedThread, setSelectedThread] = useState(null);
+    const [draftThread, setDraftThread] = useState(() => makeDraftThread(agentId));
+    // ChatGPT-style optimistic rows, keyed by thread identity: conversations listed from
+    // the moment a prompt is sent (see notifyThreadActivity), before/ahead of their server
+    // row. The display overlay hands each one over to its server row as events land.
+    // Ref-mirrored like threadsRef, for reads outside render (renameThread's snapshots).
+    const [optimisticThreads, setOptimisticThreads] = useState(new Map());
+    const optimisticThreadsRef = useRef(optimisticThreads);
+    const applyOptimisticThreads = useCallback((next) => {
+        optimisticThreadsRef.current = next;
+        setOptimisticThreads(next);
+    }, []);
+    const setCurrentThread = useCallback((thread) => {
+        // Null means "new chat": mint a fresh draft so each one is its own conversation.
+        if (!thread) {
+            setDraftThread(makeDraftThread(agentId));
+        }
+        setSelectedThread(thread);
+    }, [agentId]);
+    // Selection follows the agent, not the query: filter changes keep it (the fallback in
+    // `currentThread` covers rows the new filter drops), but another agent's thread — or
+    // draft — is meaningless here. Guarded by the previous id so the mount render keeps the
+    // initial draft (regenerating it would remount a consumer's keyed chat surface for nothing).
+    const prevAgentIdRef = useRef(agentId);
+    useEffect(() => {
+        if (prevAgentIdRef.current === agentId) {
+            return;
+        }
+        prevAgentIdRef.current = agentId;
+        setSelectedThread(null);
+        setDraftThread(makeDraftThread(agentId));
+        applyOptimisticThreads(new Map());
+    }, [agentId, applyOptimisticThreads]);
+    // The realtime merge's list-shape inputs, shared by the display overlay, the live
+    // event handler, and the walk-result reconciliation in loadFirstPage.
+    const liveUpdateOptions = useMemo(() => ({ status, source, chatId, sort, order }), [status, source, chatId, sort, order]);
+    // What consumers see: the loaded pages with the optimistic rows overlaid.
+    const displayThreads = useMemo(() => overlayOptimisticThreads(threads, optimisticThreads, liveUpdateOptions), [threads, optimisticThreads, liveUpdateOptions]);
+    // Rows are rewritten server-side every turn, so after a refresh the stored item is stale;
+    // prefer the list's row with the same identity, keep the stored one if it's not loaded.
+    // The draft goes through the same lookup: once its row is listed — optimistically on the
+    // first send, or when its first turn is indexed — that row wins under the same key: the
+    // draft has materialized, without changing identity.
+    const currentThread = useMemo(() => {
+        const stored = selectedThread ?? draftThread;
+        const storedKey = agentThreadKey(stored);
+        return displayThreads.find((thread) => agentThreadKey(thread) === storedKey) ?? stored;
+    }, [displayThreads, selectedThread, draftThread]);
+    const isDraftThread = !selectedThread && currentThread === draftThread;
+    // Once the draft's row is listed, it IS the conversation — adopt it as the selection.
+    // Otherwise a later filter change (which blanks the list before refetching) would flip
+    // `isDraftThread` back to true for a conversation that has messages, and the consumer's
+    // draft-only presentation ("New chat" header, empty-state slot) with it.
+    useEffect(() => {
+        if (selectedThread) {
+            return;
+        }
+        const draftKey = agentThreadKey(draftThread);
+        const materialized = displayThreads.find((thread) => agentThreadKey(thread) === draftKey);
+        if (materialized) {
+            setSelectedThread(materialized);
+        }
+    }, [displayThreads, selectedThread, draftThread]);
+    // Read at call time via a ref so notifyThreadActivity stays identity-stable for
+    // memoized chat surfaces (same render-time-assignment pattern as authRef below).
+    const currentThreadRef = useRef(currentThread);
+    currentThreadRef.current = currentThread;
+    /**
+     * Report a user send on the current conversation — ChatGPT-style optimistic listing.
+     * A conversation with no server row yet appears in `threads` immediately, titled by
+     * the truncated prompt, and every send bumps the row's recency. Server rows take over
+     * under the same identity as events land (turn end, title generation), the provisional
+     * title holding until the generated one arrives.
+     */
+    const notifyThreadActivity = useCallback((prompt) => {
+        const current = currentThreadRef.current;
+        const key = agentThreadKey(current);
+        const prev = optimisticThreadsRef.current;
+        const next = new Map(prev);
+        next.set(key, {
+            ...current,
+            title: prev.get(key)?.title ?? current.title ?? provisionalThreadTitle(prompt),
+            lastActivityAt: new Date().toISOString(),
+        });
+        applyOptimisticThreads(next);
+    }, [applyOptimisticThreads]);
+    // Auth material is read at request time via refs so an inline `headers` object literal
+    // doesn't churn the effect below into a refetch loop.
+    const authRef = useRef({ token: options.token, headers: options.headers });
+    authRef.current = { token: options.token, headers: options.headers };
+    // Every state-writing path checks it still owns the latest request before touching state,
+    // so a stale response (filter switched mid-flight, unmount) can never clobber a newer one.
+    const requestSeqRef = useRef(0);
+    // Authed request against the platform host, JSON-decoded — shared by the page and
+    // getOne fetchers below and by renameThread.
+    const fetchJson = useCallback(async (path, init) => {
+        const { token, headers } = authRef.current;
+        const response = await fetch(`${baseUrl ?? getApiHost()}${path}`, {
+            ...init,
+            headers: {
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                ...headers,
+                ...init?.headers,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Agent threads request failed with status ${response.status}`);
+        }
+        return (await response.json());
+    }, [baseUrl]);
+    const fetchPage = useCallback((cursor) => fetchJson(`/agent-threads/${encodeURIComponent(agentId)}${buildQuery({ status, source, chatId, limit, sort, order }, cursor)}`), [agentId, status, source, chatId, limit, sort, order, fetchJson]);
+    // getOne, mirroring the upstream GET /thread endpoint — the realtime fallback for
+    // events whose payload doesn't carry the full row.
+    const fetchThread = useCallback((threadChatId, threadChatThreadId) => fetchJson(`/agent-threads/${encodeURIComponent(agentId)}/thread?${new URLSearchParams({ chatId: threadChatId, chatThreadId: threadChatThreadId })}`), [agentId, fetchJson]);
+    /**
+     * Rename a conversation — optimistic with rollback, rejecting on failure so callers
+     * can surface it. The new title is applied to EVERY local title source: the loaded
+     * row, any optimistic entry (whose snapshot the overlay may currently be showing),
+     * and the stored selection — `currentThread`'s fallback when a filter change dropped
+     * the row from the list; without it, a rename of the open-but-unlisted conversation
+     * would never reach the header. Other tabs get the rename via the pusher event; this
+     * tab is excluded from the echo (x-socket-id), matching the optimistic apply.
+     */
+    const renameThread = useCallback(async (thread, title) => {
+        const trimmed = title.trim();
+        if (!trimmed) {
+            return;
+        }
+        const key = agentThreadKey(thread);
+        // `undefined` means "that source held no row when we started" — leave whatever is
+        // there now alone. Collapsing it to null would let a rollback erase a title that
+        // landed from the server while the request was in flight.
+        const setLocalTitle = (rowTitle, entryTitle, selectedTitle) => {
+            const row = threadsRef.current.find((item) => agentThreadKey(item) === key);
+            if (row && rowTitle !== undefined && row.title !== rowTitle) {
+                applyThreads(threadsRef.current.map((item) => (item === row ? { ...item, title: rowTitle } : item)));
+            }
+            const entry = optimisticThreadsRef.current.get(key);
+            if (entry && entryTitle !== undefined && entry.title !== entryTitle) {
+                const next = new Map(optimisticThreadsRef.current);
+                next.set(key, { ...entry, title: entryTitle });
+                applyOptimisticThreads(next);
+            }
+            setSelectedThread((prev) => prev && agentThreadKey(prev) === key && selectedTitle !== undefined && prev.title !== selectedTitle
+                ? { ...prev, title: selectedTitle }
+                : prev);
+        };
+        const previousRowTitle = threadsRef.current.find((item) => agentThreadKey(item) === key)?.title;
+        const previousEntryTitle = optimisticThreadsRef.current.get(key)?.title;
+        // currentThread IS the stored selection whenever the selection matters as a
+        // fallback (and the fresher list row otherwise) — either way, the right value
+        // to restore the selection's title to.
+        const current = currentThreadRef.current;
+        const previousSelectedTitle = agentThreadKey(current) === key ? current.title : undefined;
+        setLocalTitle(trimmed, trimmed, trimmed);
+        try {
+            const socketId = websocketsService.getSocketId();
+            const { updated } = await fetchJson(`/agent-threads/${encodeURIComponent(agentId)}/thread`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(socketId ? { "x-socket-id": socketId } : {}),
+                },
+                body: JSON.stringify({ chatId: thread.chatId, chatThreadId: thread.chatThreadId, title: trimmed }),
+            });
+            // `updated: false` means no such row upstream (e.g. renaming before the first
+            // turn indexes the conversation) — a failure like any other, or the optimistic
+            // title would stick locally and silently vanish on reload.
+            if (!updated) {
+                throw new Error("Thread rename was not applied");
+            }
+        }
+        catch (error) {
+            setLocalTitle(previousRowTitle, previousEntryTitle, previousSelectedTitle);
+            throw error;
+        }
+    }, [agentId, fetchJson, applyThreads, applyOptimisticThreads]);
+    // Realtime rows that land while a refresh walk is in flight: the walk's fetches may
+    // predate those writes, so replacing the list with the raw walk result could silently
+    // revert or drop them — re-merging afterwards keeps whichever side is newer (the
+    // merge's staleness guard makes this idempotent).
+    const liveWhileWalkingRef = useRef(null);
+    // The in-flight refresh, if any, so loadMore can wait it out instead of dropping the
+    // gesture (a click on "Load more" often arrives right behind the window-focus refresh
+    // the same gesture triggered).
+    const refreshPromiseRef = useRef(null);
+    const loadFirstPage = useCallback(() => {
+        if (!agentId) {
+            // Nothing will fetch — make sure the optimistic initial `true` (or a fetch
+            // superseded by agentId turning falsy) can't leave the loading flag latched on.
+            setIsLoading(false);
+            return Promise.resolve();
+        }
+        const requestSeq = ++requestSeqRef.current;
+        liveWhileWalkingRef.current = new Map();
+        setIsLoading(true);
+        setError(null);
+        const run = (async () => {
+            try {
+                // A refresh re-covers every page the user has already loaded — one request in the
+                // common one-page case (the query-change effect blanks the list first, so filter
+                // switches also fetch a single page). The alternatives both break pagination:
+                // replacing with page one collapses the list back to page one on every focus
+                // refresh, and splicing page one over the old tail either rewinds the cursor
+                // ("Load more" then refetches known rows and looks dead) or keeps the old cursor
+                // and permanently skips rows that arrived beyond page one while the user was away.
+                // Walking the cursor keeps the list contiguous from the top, in server order,
+                // with the cursor pointing past everything shown.
+                const loadedCount = threadsRef.current.length;
+                let items = [];
+                let cursor = null;
+                do {
+                    const page = await fetchPage(cursor);
+                    if (requestSeqRef.current !== requestSeq) {
+                        return;
+                    }
+                    if (page.items.length === 0) {
+                        // Defensive: an empty page must terminate the walk even with a non-null cursor.
+                        cursor = null;
+                        break;
+                    }
+                    items = appendPage(items, page.items);
+                    if (page.nextCursor === cursor) {
+                        // Defensive: dedupe can hold items.length under loadedCount, so a
+                        // non-advancing cursor must terminate too or the walk loops unbounded.
+                        cursor = null;
+                        break;
+                    }
+                    cursor = page.nextCursor;
+                } while (cursor !== null && items.length < loadedCount);
+                for (const live of liveWhileWalkingRef.current?.values() ?? []) {
+                    items = applyAgentThreadUpdate(items, live, { ...liveUpdateOptions, hasMore: cursor !== null });
+                }
+                applyThreads(items);
+                applyCursor(cursor);
+            }
+            catch (fetchError) {
+                if (requestSeqRef.current !== requestSeq) {
+                    return;
+                }
+                setError(fetchError instanceof Error ? fetchError : new Error(String(fetchError)));
+            }
+            finally {
+                if (requestSeqRef.current === requestSeq) {
+                    setIsLoading(false);
+                    liveWhileWalkingRef.current = null;
+                }
+            }
+        })();
+        refreshPromiseRef.current = run;
+        return run;
+    }, [agentId, fetchPage, liveUpdateOptions, applyThreads, applyCursor]);
+    // Ref-guarded rather than state-guarded: after the awaited refresh below, the closure's
+    // state flags are stale by definition — and a ref also makes double-clicks race-free.
+    const loadMoreInFlightRef = useRef(false);
+    const loadMore = useCallback(async () => {
+        if (!agentId || loadMoreInFlightRef.current) {
+            return;
+        }
+        loadMoreInFlightRef.current = true;
+        setIsLoadingMore(true);
+        // Captured BEFORE the wait below: this closure's fetchPage belongs to the render the
+        // click landed on, so anything that supersedes the list while we sit behind the
+        // refresh (a query change, a newer refresh) must invalidate this gesture too.
+        const requestSeq = requestSeqRef.current;
+        try {
+            // A refresh may be in flight — typically fired by the very window-focus that
+            // preceded this click. Wait it out instead of silently swallowing the gesture;
+            // the cursor ref then points past everything the refresh walk re-covered.
+            if (refreshPromiseRef.current) {
+                await refreshPromiseRef.current;
+            }
+            if (requestSeqRef.current !== requestSeq) {
+                return;
+            }
+            const cursor = nextCursorRef.current;
+            if (cursor === null) {
+                return;
+            }
+            const page = await fetchPage(cursor);
+            if (requestSeqRef.current !== requestSeq) {
+                return;
+            }
+            applyThreads(appendPage(threadsRef.current, page.items));
+            applyCursor(page.nextCursor);
+        }
+        catch (fetchError) {
+            if (requestSeqRef.current !== requestSeq) {
+                return;
+            }
+            setError(fetchError instanceof Error ? fetchError : new Error(String(fetchError)));
+        }
+        finally {
+            // Unconditional: even when a refresh superseded this request the flags must clear
+            // or pagination locks up.
+            loadMoreInFlightRef.current = false;
+            setIsLoadingMore(false);
+        }
+    }, [agentId, fetchPage, applyThreads, applyCursor]);
+    useEffect(() => {
+        applyThreads([]);
+        applyCursor(null);
+        // Server-side filters know nothing of the optimistic rows — drop them on a query
+        // change rather than risk re-listing a snapshot whose server truth the new filter
+        // excludes (see the retire-on-eviction note in the realtime handler below).
+        applyOptimisticThreads(new Map());
+        void loadFirstPage();
+        return () => {
+            // Invalidate in-flight requests on unmount / query change.
+            requestSeqRef.current += 1;
+        };
+    }, [loadFirstPage, applyThreads, applyCursor, applyOptimisticThreads]);
+    // Live sync: every threads-table write lands here as a serialized row, so the happy
+    // path is a pure client-side upsert; a payload without the full row falls back to the
+    // getOne endpoint. The service-level filter drops other agents' events.
+    useEffect(() => {
+        if (!agentId) {
+            return;
+        }
+        const onThreadUpdated = async (data) => {
+            // Same superseded-request contract as the fetch paths, guarding the async fallback
+            // (trivially true on the no-await happy path).
+            const requestSeq = requestSeqRef.current;
+            try {
+                const raw = data?.thread;
+                let incoming;
+                if (isAgentThreadItem(raw)) {
+                    incoming = raw;
+                }
+                else if (typeof raw?.chatId === "string" && typeof raw.chatThreadId === "string") {
+                    incoming = await fetchThread(raw.chatId, raw.chatThreadId);
+                }
+                else {
+                    return;
+                }
+                if (requestSeqRef.current !== requestSeq) {
+                    return;
+                }
+                const key = agentThreadKey(incoming);
+                // An authoritative row the active filters reject must retire the thread's
+                // optimistic entry too: the merge below evicts the server row, and with no
+                // listed row there is no staleness guard to stop the overlay from re-adding
+                // the entry's stale snapshot — which no later event or refresh walk could
+                // correct, since the server filters the row out as well. Gated on turnCount
+                // (server-monotonic, like the overlay's handover) rather than the entry's
+                // CLIENT-stamped lastActivityAt, which a fast browser clock could hold ahead
+                // of every server timestamp.
+                const entry = optimisticThreadsRef.current.get(key);
+                if (entry && !matchesAgentThreadFilters(incoming, liveUpdateOptions) && incoming.turnCount >= entry.turnCount) {
+                    const next = new Map(optimisticThreadsRef.current);
+                    next.delete(key);
+                    applyOptimisticThreads(next);
+                }
+                // Park the row for the in-flight refresh walk (if any) — its fetches may
+                // predate this write — then merge it into the current list.
+                liveWhileWalkingRef.current?.set(key, incoming);
+                applyThreads(applyAgentThreadUpdate(threadsRef.current, incoming, {
+                    ...liveUpdateOptions,
+                    hasMore: nextCursorRef.current !== null,
+                }));
+            }
+            catch {
+                // Best-effort: a failed fallback fetch skips this event — the next event or a
+                // recovery refresh re-converges. Must not reject; the websocket service doesn't catch.
+            }
+        };
+        websocketsService.listen(AGENT_THREAD_UPDATED, onThreadUpdated, { filter: { agentId } });
+        return () => {
+            websocketsService.unlisten(AGENT_THREAD_UPDATED, onThreadUpdated);
+        };
+    }, [agentId, liveUpdateOptions, fetchThread, applyThreads, applyOptimisticThreads]);
+    return {
+        threads: displayThreads,
+        currentThread,
+        isDraftThread,
+        setCurrentThread,
+        notifyThreadActivity,
+        renameThread,
+        isLoading,
+        isLoadingMore,
+        error,
+        hasMore: nextCursor !== null,
+        loadMore,
+        refresh: loadFirstPage,
+    };
+};
+export default useAgentThreads;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./hooks/use-agent-threads.js";
 export * from "./hooks/use-ai-stream-chunks.js";
 export * from "./components/agent-chat.js";
 export * from "./iframe-communication/index.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from "./hooks/use-agent-threads.js";
 export * from "./hooks/use-ai-stream-chunks.js";
 export * from "./components/agent-chat.js";
 export * from "./iframe-communication/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocksdiy/react-common",
-  "version": "1.39.0",
+  "version": "1.41.0",
   "type": "module",
   "description": "React common",
   "keywords": [],
@@ -11,6 +11,7 @@
   "exports": {
     ".": "./dist/index.js",
     "./useAiStreamChunks": "./dist/hooks/use-ai-stream-chunks.js",
+    "./agent-threads": "./dist/hooks/use-agent-threads.js",
     "./agent-chat": "./dist/components/agent-chat.js",
     "./new-agent-chat": "./dist/components/new-agent-chat.js",
     "./iframe-communication": "./dist/iframe-communication/index.js"