@blocksdiy/react-common 1.52.1 → 1.53.0

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

@@ -0,0 +1,193 @@
+// One conversation's row, live — the reader for a surface that shows a single conversation
+// without the agent's index (the floating agent chat on a page). It reads from the agent's
+// shared store: a row the index already walked costs nothing; otherwise one single-thread read,
+// deferred while an index for the agent is still walking so the two never race for the same row.
+// A draft (the new chat, nothing sent) reads nothing: the server has no row for it yet.
+// The result wears the index result's shape (one row or none), so `useAgentConversation` and
+// `AgentConversationProvider`'s root run on it unchanged. The decisions are pure and tested
+// (`singleThreadMountPlan`, `singleThreadEventOutcome`); the hook is the React shell around them.
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { agentThreadKey, optimisticThreadAfterSend, overlayOptimisticThreads, retireOptimisticThreadsTakenOver, } from "./agent-thread-live-update.js";
+import { acquireAgentThreadStore } from "./agent-thread-store.js";
+import { agentThreadPath, AgentThreadsRequestError, postAgentThreadRename, useAgentThreadsFetchJson, } from "./use-agent-threads.js";
+/**
+ * Mount: the store's row when the index already has it; a draft reads nothing; otherwise one
+ * read — deferred while an index is walking, so the two never race for the same row.
+ */
+export const singleThreadMountPlan = (store, key, isDraft) => {
+    const cached = store.getRow(key);
+    if (cached) {
+        return { kind: "cached", thread: cached };
+    }
+    if (isDraft) {
+        return { kind: "draft" };
+    }
+    return store.isIndexLoading ? { kind: "await-index" } : { kind: "read" };
+};
+/**
+ * The cache is the row's source of truth: it keeps the newest row it has seen, so what it holds
+ * is what the surface shows — a stale wire event, or a page an index walked later, never
+ * regresses it. `awaitingIndex`: the mount deferred its read to a walking index.
+ */
+export const singleThreadEventOutcome = (event, store, key, awaitingIndex) => {
+    if (event.kind === "primed") {
+        const primed = store.getRow(key);
+        if (primed) {
+            return { kind: "row", thread: primed };
+        }
+        return awaitingIndex && !store.isIndexLoading ? { kind: "read" } : { kind: "ignore" };
+    }
+    if (event.kind === "removed") {
+        return agentThreadKey(event.removed) === key ? { kind: "removed" } : { kind: "ignore" };
+    }
+    if (agentThreadKey(event.thread) !== key) {
+        return { kind: "ignore" };
+    }
+    return { kind: "row", thread: store.getRow(key) ?? event.thread };
+};
+/** The single-thread read's "no row" answer — a conversation the server has not seen — as opposed to a failure. */
+export const isMissingRowError = (error) => error instanceof AgentThreadsRequestError && error.status === 404;
+const noop = async () => undefined;
+export const useAgentThread = ({ agentId, conversation, isDraft = false, token, headers, baseUrl, }) => {
+    const key = agentThreadKey(conversation);
+    // Keyed by identity, not by object: a caller handing a fresh `{ chatId, chatThreadId }` each
+    // render must not re-acquire the store and refetch each render.
+    const target = useMemo(() => ({
+        chatId: conversation.chatId,
+        chatThreadId: conversation.chatThreadId,
+    }), [conversation.chatId, conversation.chatThreadId]);
+    const [thread, setThread] = useState(null);
+    // The optimistic row after this client's own send, overlaid until the server's row shows the
+    // run — the index's rule, applied to a list of one (the same helpers).
+    const [optimistic, setOptimistic] = useState(null);
+    const [isLoading, setIsLoading] = useState(Boolean(agentId) && !isDraft);
+    const [error, setError] = useState(null);
+    const fetchJson = useAgentThreadsFetchJson({ baseUrl, token, headers });
+    // Read at call time, not a dependency: the draft turning into a thread must not re-acquire
+    // the store or re-read — its row comes over the wire.
+    const isDraftRef = useRef(isDraft);
+    isDraftRef.current = isDraft;
+    const fetchRow = useCallback((target) => fetchJson(agentThreadPath(agentId, target)), [agentId, fetchJson]);
+    const storeHandleRef = useRef(null);
+    const requestSeqRef = useRef(0);
+    /** Read the row from the server; a row the server has none for yet reads as null, not an error. A draft reads nothing. */
+    const refresh = useCallback(async () => {
+        if (!agentId || isDraftRef.current) {
+            setIsLoading(false);
+            return;
+        }
+        const requestSeq = ++requestSeqRef.current;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const row = await fetchRow(target);
+            if (requestSeqRef.current !== requestSeq) {
+                return;
+            }
+            // Through the cache: a live update that landed while the read was in flight is newer
+            // than what the read returned, and the cache kept the newer of the two.
+            const store = storeHandleRef.current?.store;
+            store?.prime([row]);
+            setThread(store?.getRow(key) ?? row);
+        }
+        catch (fetchError) {
+            if (requestSeqRef.current !== requestSeq) {
+                return;
+            }
+            if (isMissingRowError(fetchError)) {
+                setThread(null);
+            }
+            else {
+                setError(fetchError instanceof Error ? fetchError : new Error(String(fetchError)));
+            }
+        }
+        finally {
+            if (requestSeqRef.current === requestSeq) {
+                setIsLoading(false);
+            }
+        }
+    }, [agentId, target, key, fetchRow]);
+    useEffect(() => {
+        if (!agentId) {
+            return;
+        }
+        const handle = acquireAgentThreadStore(agentId, { fetchThread: fetchRow });
+        storeHandleRef.current = handle;
+        const { store } = handle;
+        setThread(null);
+        setOptimistic(null);
+        const plan = singleThreadMountPlan(store, key, isDraftRef.current);
+        let awaitingIndex = plan.kind === "await-index";
+        if (plan.kind === "cached") {
+            setThread(plan.thread);
+            setIsLoading(false);
+        }
+        else if (plan.kind === "read") {
+            void refresh();
+        }
+        else {
+            setIsLoading(awaitingIndex);
+        }
+        const unsubscribe = store.subscribe((event) => {
+            const outcome = singleThreadEventOutcome(event, store, key, awaitingIndex);
+            if (outcome.kind === "row") {
+                awaitingIndex = false;
+                setThread(outcome.thread);
+                setIsLoading(false);
+            }
+            else if (outcome.kind === "read") {
+                awaitingIndex = false;
+                void refresh();
+            }
+            else if (outcome.kind === "removed") {
+                // A ghost thread (a run that ended before any turn) is gone; a conversation with turns stays.
+                setThread((current) => (current && current.turnCount > 0 ? current : null));
+            }
+        });
+        return () => {
+            requestSeqRef.current += 1;
+            unsubscribe();
+            storeHandleRef.current = null;
+            handle.release();
+        };
+    }, [agentId, key, fetchRow, refresh]);
+    const notifyThreadActivity = useCallback((row, prompt) => {
+        setOptimistic((previous) => optimisticThreadAfterSend(row, previous ?? undefined, prompt, new Date().toISOString()));
+    }, []);
+    const renameThread = useCallback(async (target, title) => {
+        const trimmed = title.trim();
+        if (!trimmed || agentThreadKey(target) !== key) {
+            return;
+        }
+        const previousTitle = thread?.title;
+        setThread((current) => (current ? { ...current, title: trimmed } : current));
+        try {
+            await postAgentThreadRename(fetchJson, agentId, target, trimmed, storeHandleRef.current?.store);
+        }
+        catch (renameError) {
+            setThread((current) => (current ? { ...current, title: previousTitle ?? null } : current));
+            throw renameError;
+        }
+    }, [agentId, fetchJson, key, thread?.title]);
+    const threads = useMemo(() => {
+        const listed = thread ? [thread] : [];
+        if (!optimistic) {
+            return listed;
+        }
+        // Retired for good once the server row shows the run; overlaid until then.
+        const remaining = retireOptimisticThreadsTakenOver(new Map([[key, optimistic]]), listed);
+        return overlayOptimisticThreads(listed, remaining);
+    }, [thread, optimistic, key]);
+    return {
+        thread: threads[0] ?? null,
+        threads,
+        notifyThreadActivity,
+        renameThread,
+        isLoading,
+        isLoadingMore: false,
+        error,
+        hasMore: false,
+        loadMore: noop,
+        refresh,
+    };
+};

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

@@ -1,8 +1,40 @@
 import { type AgentThreadItem, type AgentThreadSource, type AgentThreadStatus } from "./agent-thread-live-update.js";
+import { type AgentThreadStore } from "./agent-thread-store.js";
 export * from "./agent-thread-live-update.js";
 export { type AgentAdminCaller, BUILD_PERMISSION, isAgentAdmin, readAgentAdminRoles } from "../utils/agent-admin.js";
 export { type AgentConversationChat, type AgentConversationRef, type AgentConversationUrlTarget, agentThreadStandIn, nextRunStaleAt, RUN_STALE_MS, useAgentConversation, type UseAgentConversationOptions, type UseAgentConversationResult, useAgentConversationSelection, type UseAgentConversationSelectionOptions, type UseAgentConversationSelectionResult, } from "./use-agent-conversation.js";
-export { type AgentConversationContextValue, AgentConversationProvider, type AgentConversationProviderProps, type AgentThreadFilters, useAgentConversationContext, } from "./agent-conversation-context.js";
+export { type AgentConversationContextValue, AgentConversationProvider, type AgentConversationProviderProps, AgentThreadConversationProvider, type AgentThreadConversationProviderProps, type AgentThreadFilters, useAgentConversationContext, } from "./agent-conversation-context.js";
+export { useAgentThread, type UseAgentThreadOptions, type UseAgentThreadResult } from "./use-agent-thread.js";
+export { useMediaQuery } from "./use-media-query.js";
+export { type FloatingAgentChatExpandHref, type FloatingAgentChatHandle, type FloatingAgentChatOpenOptions, type FloatingAgentChatOpenRequest, type FloatingAgentChatState, type FloatingAgentChatTarget, floatingAgentChatAfterDraftSent, floatingAgentChatAfterOpen, isFloatingAgentChatDraft, useFloatingAgentChatController, type UseFloatingAgentChatControllerResult, } from "./floating-agent-chat.js";
+export { clampPanelSize, type PanelResizeAxis, type PanelResizeBounds, type PanelResizeHandleProps, type PanelSize, parseStoredPanelSize, useResizablePanel, type UseResizablePanelOptions, type UseResizablePanelResult, } from "./use-resizable-panel.js";
+/** The auth a reader carries — its SDK token and extra headers — read at call time. */
+export interface AgentThreadsAuth {
+    token?: string;
+    headers?: Record<string, string>;
+}
+/** A non-2xx answer from the agent-threads API, with its status — a reader tells a 404 (no row) from a failure. */
+export declare class AgentThreadsRequestError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+/** One request against the agent-threads API; every reader (index, single thread) goes through it. */
+export declare const agentThreadsFetchJson: <T>(baseUrl: string | undefined, auth: AgentThreadsAuth, path: string, init?: RequestInit) => Promise<T>;
+/**
+ * The request function a reader holds. Its auth is read at call time: a token refresh changes
+ * nothing a reader depends on, so it never re-acquires a store or re-reads for it.
+ */
+export declare const useAgentThreadsFetchJson: ({ baseUrl, token, headers, }: AgentThreadsAuth & {
+    baseUrl?: string;
+}) => (<T>(path: string, init?: RequestInit) => Promise<T>);
+/** The single-thread read: one row by its (chatId, chatThreadId) identity under the agent. */
+export declare const agentThreadPath: (agentId: string, conversation: Pick<AgentThreadItem, "chatId" | "chatThreadId">) => string;
+/**
+ * The rename, as the server applies it. The `x-socket-id` lets the publish skip this tab — the
+ * caller already shows the new title optimistically — so, that publish never coming back, the
+ * renamed row is handed to the agent's shared store here, for every other reader of it.
+ */
+export declare const postAgentThreadRename: (fetchJson: <T>(path: string, init?: RequestInit) => Promise<T>, agentId: string, thread: Pick<AgentThreadItem, "chatId" | "chatThreadId">, title: string, store?: Pick<AgentThreadStore, "getRow" | "prime">) => Promise<void>;
 export interface AgentThreadsPage {
     items: AgentThreadItem[];
     nextCursor: string | null;

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

@@ -1 +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,EAUvB,MAAM,4BAA4B,CAAC;AAEpC,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAClH,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,6BAA6B,EAC7B,KAAK,oCAAoC,EACzC,KAAK,mCAAmC,GACzC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,6BAA6B,EAClC,yBAAyB,EACzB,KAAK,8BAA8B,EACnC,KAAK,kBAAkB,EACvB,2BAA2B,GAC5B,MAAM,8BAA8B,CAAC;AAItC,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,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,oBAAoB,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,YAAY,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzG,SAAS,EAAE,OAAO,CAAC;IACnB,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,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAgD,CAAC;AAEpG,eAAO,MAAM,qBAAqB,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,CAAC,KAAG,MAIhG,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,KAAG,MACpD,CAAC;AAuC1D,0FAA0F;AAC1F,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB,KAAG,qBA6UjE,CAAC;AAEF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"use-agent-threads.d.ts","sourceRoot":"","sources":["../../src/hooks/use-agent-threads.ts"],"names":[],"mappings":"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"}

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

@@ -1,12 +1,79 @@
 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, optimisticThreadAfterSend, overlayOptimisticThreads, reconcileWalkWithLive, removeAgentThread, retireOptimisticThreadsTakenOver, } from "./agent-thread-live-update.js";
+import { agentThreadKey, applyAgentThreadUpdate, matchesAgentThreadFilters, optimisticThreadAfterSend, overlayOptimisticThreads, reconcileWalkWithLive, removeAgentThread, retireOptimisticThreadsTakenOver, } from "./agent-thread-live-update.js";
+import { acquireAgentThreadStore } from "./agent-thread-store.js";
 export * from "./agent-thread-live-update.js";
 export { BUILD_PERMISSION, isAgentAdmin, readAgentAdminRoles } from "../utils/agent-admin.js";
 export { agentThreadStandIn, nextRunStaleAt, RUN_STALE_MS, useAgentConversation, useAgentConversationSelection, } from "./use-agent-conversation.js";
-export { AgentConversationProvider, useAgentConversationContext, } from "./agent-conversation-context.js";
-const AGENT_THREAD_UPDATED = "AGENT_THREAD_UPDATED";
+export { AgentConversationProvider, AgentThreadConversationProvider, useAgentConversationContext, } from "./agent-conversation-context.js";
+export { useAgentThread } from "./use-agent-thread.js";
+export { useMediaQuery } from "./use-media-query.js";
+export { floatingAgentChatAfterDraftSent, floatingAgentChatAfterOpen, isFloatingAgentChatDraft, useFloatingAgentChatController, } from "./floating-agent-chat.js";
+export { clampPanelSize, parseStoredPanelSize, useResizablePanel, } from "./use-resizable-panel.js";
+/** A non-2xx answer from the agent-threads API, with its status — a reader tells a 404 (no row) from a failure. */
+export class AgentThreadsRequestError extends Error {
+    status;
+    constructor(status) {
+        super(`Agent threads request failed with status ${status}`);
+        this.status = status;
+        this.name = "AgentThreadsRequestError";
+    }
+}
+/** One request against the agent-threads API; every reader (index, single thread) goes through it. */
+export const agentThreadsFetchJson = async (baseUrl, auth, path, init) => {
+    const response = await fetch(`${baseUrl ?? getApiHost()}${path}`, {
+        ...init,
+        headers: {
+            ...(auth.token ? { Authorization: `Bearer ${auth.token}` } : {}),
+            ...auth.headers,
+            ...init?.headers,
+        },
+    });
+    if (!response.ok) {
+        throw new AgentThreadsRequestError(response.status);
+    }
+    return (await response.json());
+};
+/**
+ * The request function a reader holds. Its auth is read at call time: a token refresh changes
+ * nothing a reader depends on, so it never re-acquires a store or re-reads for it.
+ */
+export const useAgentThreadsFetchJson = ({ baseUrl, token, headers, }) => {
+    const authRef = useRef({ token, headers });
+    useEffect(() => {
+        authRef.current = { token, headers };
+    });
+    return useCallback((path, init) => agentThreadsFetchJson(baseUrl, authRef.current, path, init), [baseUrl]);
+};
+/** The single-thread read: one row by its (chatId, chatThreadId) identity under the agent. */
+export const agentThreadPath = (agentId, conversation) => `/agent-threads/${encodeURIComponent(agentId)}/thread?${new URLSearchParams({
+    chatId: conversation.chatId,
+    chatThreadId: conversation.chatThreadId,
+})}`;
+/**
+ * The rename, as the server applies it. The `x-socket-id` lets the publish skip this tab — the
+ * caller already shows the new title optimistically — so, that publish never coming back, the
+ * renamed row is handed to the agent's shared store here, for every other reader of it.
+ */
+export const postAgentThreadRename = async (fetchJson, agentId, thread, title, store) => {
+    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 }),
+    });
+    if (!updated) {
+        throw new Error("Thread rename was not applied");
+    }
+    const cached = store?.getRow(agentThreadKey(thread));
+    if (store && cached) {
+        store.prime([{ ...cached, title }]);
+    }
+};
 export const AGENT_INBOX_CHAT_PREFIX = "agent-inbox-";
 export const agentInboxChatId = (agentId) => `${AGENT_INBOX_CHAT_PREFIX}${agentId}`;
 export const agentThreadShortLabel = (thread) => {
@@ -81,26 +148,17 @@ export const useAgentThreads = (options) => {
         next.set(agentThreadKey(thread), optimisticThreadAfterSend(thread, prev.get(agentThreadKey(thread)), prompt, new Date().toISOString()));
         applyOptimisticThreads(next);
     }, [applyOptimisticThreads]);
-    const authRef = useRef({ token: options.token, headers: options.headers });
-    authRef.current = { token: options.token, headers: options.headers };
+    const fetchJson = useAgentThreadsFetchJson({ baseUrl, token: options.token, headers: options.headers });
     const requestSeqRef = useRef(0);
-    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]);
-    const fetchThread = useCallback((threadChatId, threadChatThreadId) => fetchJson(`/agent-threads/${encodeURIComponent(agentId)}/thread?${new URLSearchParams({ chatId: threadChatId, chatThreadId: threadChatThreadId })}`), [agentId, fetchJson]);
+    // The agent's shared store: one live subscription and one row cache for every reader in the
+    // app. This index is its priming reader — its pages land in the cache, so a single-conversation
+    // reader beside it (the floating agent chat over a mini-app page) never fetches what the index
+    // already has. Acquired per agent; the handlers below read refs, so the handle outlives filter
+    // changes.
+    const storeHandleRef = useRef(null);
+    const liveUpdateOptionsRef = useRef(liveUpdateOptions);
+    liveUpdateOptionsRef.current = liveUpdateOptions;
     const renameThread = useCallback(async (thread, title) => {
         const trimmed = title.trim();
         if (!trimmed) {
@@ -123,18 +181,7 @@ export const useAgentThreads = (options) => {
         const previousEntryTitle = optimisticThreadsRef.current.get(key)?.title;
         setLocalTitle(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 }),
-            });
-            if (!updated) {
-                throw new Error("Thread rename was not applied");
-            }
+            await postAgentThreadRename(fetchJson, agentId, thread, trimmed, storeHandleRef.current?.store);
         }
         catch (error) {
             setLocalTitle(previousRowTitle, previousEntryTitle);
@@ -151,6 +198,7 @@ export const useAgentThreads = (options) => {
         const requestSeq = ++requestSeqRef.current;
         liveWhileWalkingRef.current = new Map();
         setIsLoading(true);
+        storeHandleRef.current?.setIndexLoading(true);
         setError(null);
         const run = (async () => {
             try {
@@ -181,6 +229,7 @@ export const useAgentThreads = (options) => {
                 }
                 applyThreads(items);
                 applyCursor(cursor);
+                storeHandleRef.current?.store.prime(items);
             }
             catch (fetchError) {
                 if (requestSeqRef.current !== requestSeq) {
@@ -191,6 +240,7 @@ export const useAgentThreads = (options) => {
             finally {
                 if (requestSeqRef.current === requestSeq) {
                     setIsLoading(false);
+                    storeHandleRef.current?.setIndexLoading(false);
                     liveWhileWalkingRef.current = null;
                 }
             }
@@ -223,6 +273,7 @@ export const useAgentThreads = (options) => {
             }
             applyThreads(appendPage(threadsRef.current, page.items));
             applyCursor(page.nextCursor);
+            storeHandleRef.current?.store.prime(page.items);
         }
         catch (fetchError) {
             if (requestSeqRef.current !== requestSeq) {
@@ -235,69 +286,67 @@ export const useAgentThreads = (options) => {
             setIsLoadingMore(false);
         }
     }, [agentId, fetchPage, applyThreads, applyCursor]);
-    useEffect(() => {
-        applyThreads([]);
-        applyCursor(null);
-        applyOptimisticThreads(new Map());
-        void loadFirstPage();
-        return () => {
-            requestSeqRef.current += 1;
-        };
-    }, [loadFirstPage, applyThreads, applyCursor, applyOptimisticThreads]);
+    // The store handle and this index's view of its events. Declared before the load effect below,
+    // so the first page's walk finds the handle (effects run in declaration order).
     useEffect(() => {
         if (!agentId) {
             return;
         }
-        const onThreadUpdated = async (data) => {
-            const requestSeq = requestSeqRef.current;
-            try {
-                const event = data;
-                const raw = event?.thread;
-                if (typeof raw?.chatId !== "string" || typeof raw.chatThreadId !== "string") {
-                    return;
-                }
-                const identity = { chatId: raw.chatId, chatThreadId: raw.chatThreadId };
-                const key = agentThreadKey(identity);
-                if (event?.removed) {
-                    const removed = { ...identity, runningRunId: raw.runningRunId };
-                    const removal = removeAgentThread(threadsRef.current, optimisticThreadsRef.current, removed);
-                    if (!removal) {
-                        return;
-                    }
-                    liveWhileWalkingRef.current?.set(key, { removed });
-                    if (removal.threads !== threadsRef.current) {
-                        applyThreads(removal.threads);
-                    }
-                    if (removal.optimistic !== optimisticThreadsRef.current) {
-                        applyOptimisticThreads(removal.optimistic);
-                    }
+        const handle = acquireAgentThreadStore(agentId, {
+            fetchThread: (conversation) => fetchJson(agentThreadPath(agentId, conversation)),
+            isIndex: true,
+        });
+        storeHandleRef.current = handle;
+        const onStoreEvent = (event) => {
+            if (event.kind === "primed") {
+                return;
+            }
+            const liveUpdateOptions = liveUpdateOptionsRef.current;
+            if (event.kind === "removed") {
+                const { removed } = event;
+                const removal = removeAgentThread(threadsRef.current, optimisticThreadsRef.current, removed);
+                if (!removal) {
                     return;
                 }
-                const incoming = isAgentThreadItem(raw) ? raw : await fetchThread(identity.chatId, identity.chatThreadId);
-                if (requestSeqRef.current !== requestSeq) {
-                    return;
+                liveWhileWalkingRef.current?.set(agentThreadKey(removed), { removed });
+                if (removal.threads !== threadsRef.current) {
+                    applyThreads(removal.threads);
                 }
-                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);
+                if (removal.optimistic !== optimisticThreadsRef.current) {
+                    applyOptimisticThreads(removal.optimistic);
                 }
-                liveWhileWalkingRef.current?.set(key, incoming);
-                applyThreads(applyAgentThreadUpdate(threadsRef.current, incoming, {
-                    ...liveUpdateOptions,
-                    hasMore: nextCursorRef.current !== null,
-                }));
+                return;
             }
-            catch {
-                // Best-effort: websocket handler must not reject.
+            const incoming = event.thread;
+            const key = agentThreadKey(incoming);
+            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);
             }
+            liveWhileWalkingRef.current?.set(key, incoming);
+            applyThreads(applyAgentThreadUpdate(threadsRef.current, incoming, {
+                ...liveUpdateOptions,
+                hasMore: nextCursorRef.current !== null,
+            }));
         };
-        websocketsService.listen(AGENT_THREAD_UPDATED, onThreadUpdated, { filter: { agentId } });
+        const unsubscribe = handle.store.subscribe(onStoreEvent);
         return () => {
-            websocketsService.unlisten(AGENT_THREAD_UPDATED, onThreadUpdated);
+            unsubscribe();
+            storeHandleRef.current = null;
+            handle.release();
         };
-    }, [agentId, liveUpdateOptions, fetchThread, applyThreads, applyOptimisticThreads]);
+    }, [agentId, fetchJson, applyThreads, applyOptimisticThreads]);
+    useEffect(() => {
+        applyThreads([]);
+        applyCursor(null);
+        applyOptimisticThreads(new Map());
+        void loadFirstPage();
+        return () => {
+            requestSeqRef.current += 1;
+        };
+    }, [loadFirstPage, applyThreads, applyCursor, applyOptimisticThreads]);
     // Realtime has no replay — reconnect re-walks; last socket id lives in a ref so a filter switch while offline does not look like a first connect.
     const lastSocketIdRef = useRef(undefined);
     useEffect(() => websocketsService.onSocketIdChange((socketId) => {

package/dist/hooks/use-media-query.d.ts

@@ -0,0 +1,2 @@
+export declare const useMediaQuery: (query: string) => boolean;
+//# sourceMappingURL=use-media-query.d.ts.map

package/dist/hooks/use-media-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-query.d.ts","sourceRoot":"","sources":["../../src/hooks/use-media-query.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,OAc7C,CAAC"}

package/dist/hooks/use-media-query.js

@@ -0,0 +1,11 @@
+// A media query's current match, subscribed — for layout decisions that CSS alone cannot make
+// (which surface a pick opens, not how it looks). False where there is no window.
+import { useCallback, useSyncExternalStore } from "react";
+export const useMediaQuery = (query) => {
+    const subscribe = useCallback((onChange) => {
+        const list = window.matchMedia(query);
+        list.addEventListener("change", onChange);
+        return () => list.removeEventListener("change", onChange);
+    }, [query]);
+    return useSyncExternalStore(subscribe, () => window.matchMedia(query).matches, () => false);
+};

package/dist/hooks/use-resizable-panel.d.ts

@@ -0,0 +1,66 @@
+export interface PanelSize {
+    width: number;
+    height: number;
+}
+/** Which dimension a handle resizes: the top edge the height, the end edge the width, the corner both. */
+export type PanelResizeAxis = "width" | "height" | "both";
+export interface PanelResizeBounds {
+    /** Pixel floor: the smallest usable panel. */
+    minSize: PanelSize;
+    /** The gap the panel keeps from the viewport's edges, in px. */
+    inset: number;
+}
+/**
+ * A size the panel can take inside `viewport`: never below the floor, never past the viewport
+ * minus the inset on both sides — unless the viewport itself is smaller than the floor, where
+ * the floor wins (CSS still caps the box to the viewport).
+ */
+export declare const clampPanelSize: (size: PanelSize, viewport: PanelSize, { minSize, inset }: PanelResizeBounds) => PanelSize;
+/** A stored size, or null for anything but two finite positive numbers. */
+export declare const parseStoredPanelSize: (raw: string | null | undefined) => PanelSize | null;
+interface ResizeDrag {
+    pointerId: number;
+    axis: PanelResizeAxis;
+    startX: number;
+    startY: number;
+    startSize: PanelSize;
+    viewport: PanelSize;
+    isRtl: boolean;
+}
+/**
+ * The size a drag has reached. The panel is anchored at the viewport's bottom-start corner, so
+ * growth is toward the end edge and upward — the horizontal delta flips in RTL, and a drag up
+ * counts as more height.
+ */
+export declare const panelSizeFromDrag: (drag: ResizeDrag, pointer: {
+    clientX: number;
+    clientY: number;
+}, bounds: PanelResizeBounds) => PanelSize;
+/** The key's step for a handle: toward the end edge and up grow; null for a key the axis ignores. */
+export declare const panelKeyboardDelta: (key: string, axis: PanelResizeAxis, step: number, isRtl: boolean) => {
+    dx: number;
+    dy: number;
+} | null;
+export interface UseResizablePanelOptions extends PanelResizeBounds {
+    /** The size before anyone resizes. */
+    defaultSize: PanelSize;
+    /** Where the size is remembered (localStorage); omit for a size that forgets on unmount. */
+    storageKey?: string;
+}
+export interface PanelResizeHandleProps {
+    onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+    onPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+    onPointerUp: (event: React.PointerEvent<HTMLElement>) => void;
+    onPointerCancel: () => void;
+    onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+}
+export interface UseResizablePanelResult {
+    size: PanelSize;
+    /** A pointer drag is in progress (the component disables text selection meanwhile). */
+    isResizing: boolean;
+    /** The handlers for a handle that resizes `axis`; spread them on the handle element. */
+    getHandleProps: (axis: PanelResizeAxis) => PanelResizeHandleProps;
+}
+export declare const useResizablePanel: (panelRef: React.RefObject<HTMLElement | null>, { defaultSize, minSize, inset, storageKey }: UseResizablePanelOptions) => UseResizablePanelResult;
+export {};
+//# sourceMappingURL=use-resizable-panel.d.ts.map

package/dist/hooks/use-resizable-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-resizable-panel.d.ts","sourceRoot":"","sources":["../../src/hooks/use-resizable-panel.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,0GAA0G;AAC1G,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1D,MAAM,WAAW,iBAAiB;IAChC,8CAA8C;IAC9C,OAAO,EAAE,SAAS,CAAC;IACnB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;CACf;AAID;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,SAAS,EACf,UAAU,SAAS,EACnB,oBAAoB,iBAAiB,KACpC,SAOF,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,SAAS,GAAG,IAwBjF,CAAC;AAEF,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,UAAU,EAChB,SAAS;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC7C,QAAQ,iBAAiB,KACxB,SAWF,CAAC;AAEF,qGAAqG;AACrG,eAAO,MAAM,kBAAkB,GAC7B,KAAK,MAAM,EACX,MAAM,eAAe,EACrB,MAAM,MAAM,EACZ,OAAO,OAAO,KACb;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAgB/B,CAAC;AAqCF,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,sCAAsC;IACtC,WAAW,EAAE,SAAS,CAAC;IACvB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IAChE,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IAChE,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;IAC9D,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;CAC9D;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,SAAS,CAAC;IAChB,uFAAuF;IACvF,UAAU,EAAE,OAAO,CAAC;IACpB,wFAAwF;IACxF,cAAc,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,sBAAsB,CAAC;CACnE;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAU,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAC7C,6CAA6C,wBAAwB,KACpE,uBAiFF,CAAC"}