@cubos/agent-sdk-react 0.0.1136563

package/dist/index.js

@@ -0,0 +1,876 @@
+// src/blocks.ts
+import { createElement, Fragment } from "react";
+function renderBlocks(message, options = {}) {
+  if (message.blocks === undefined)
+    return null;
+  const out = [];
+  for (const [index, block] of message.blocks.entries()) {
+    const node = renderBlock(block, `${message.id}:${index}`, options);
+    if (node !== null)
+      out.push(node);
+  }
+  return out;
+}
+function renderBlock(block, key, options) {
+  if (block.type === "markdown") {
+    if (block.text.trim() === "")
+      return null;
+    const node = options.renderMarkdown?.(block.text) ?? block.text;
+    return createElement(Fragment, { key }, options.wrapBlock?.(node, block) ?? node);
+  }
+  const render = options.components?.[block.tag];
+  if (!render)
+    return null;
+  if (options.wrapBlock === undefined)
+    return createElement(render, { ...block.props, key });
+  return createElement(Fragment, { key }, options.wrapBlock(createElement(render, block.props), block));
+}
+// src/context.tsx
+import { createUserClient } from "@cubos/agent-sdk";
+import { createContext, createElement as createElement2, useContext, useMemo, useRef } from "react";
+var AgentContext = createContext(null);
+function AgentProvider({ children, ...options }) {
+  const credentialRef = useRef(options);
+  credentialRef.current = options;
+  const client = useMemo(() => createUserClient({
+    baseUrl: options.baseUrl,
+    tenant: options.tenant,
+    fetch: options.fetch,
+    timeoutMs: options.timeoutMs,
+    getToken: (opts) => {
+      const current = credentialRef.current;
+      return "getToken" in current ? current.getToken(opts) : current.token;
+    }
+  }), [options.baseUrl, options.tenant, options.fetch, options.timeoutMs]);
+  return createElement2(AgentContext.Provider, { value: client }, children);
+}
+function useAgentClient() {
+  const client = useContext(AgentContext);
+  if (!client) {
+    throw new Error("No AgentProvider found. Wrap your app in <AgentProvider baseUrl=… getToken=…>.");
+  }
+  return client;
+}
+// src/use-conversation.ts
+import {
+  mergeToolActivities,
+  mergeVoiceMessages
+} from "@cubos/agent-sdk";
+import { useCallback, useEffect, useMemo as useMemo2, useRef as useRef2, useState } from "react";
+var IDLE = { isProcessing: false, hasPendingTurn: false };
+function mergeMessages(existing, incoming) {
+  const byId = new Map(existing.map((m) => [m.id, m]));
+  for (const m of incoming)
+    byId.set(m.id, m);
+  const held = [...byId.values()];
+  const arrived = new Set(held.filter((m) => !isOptimistic(m)).map((m) => optimisticIdFor(m)));
+  const ordered = held.filter((m) => !(isOptimistic(m) && arrived.has(m.id))).sort((a, b) => a.seq - b.seq);
+  return mergeVoiceMessages(ordered);
+}
+function isOptimistic(message) {
+  return message.id.startsWith("optimistic:");
+}
+function trailOf(message, messages, activity) {
+  if (message.role !== "agent" || activity.length === 0)
+    return [];
+  let previousSeq = -1;
+  for (const m of messages) {
+    if (m.seq >= message.seq)
+      break;
+    previousSeq = m.seq;
+  }
+  return activity.filter((a) => a.seq > previousSeq && a.seq < message.seq);
+}
+function trailAfterLast(messages, activity) {
+  if (activity.length === 0)
+    return [];
+  let lastSeq = -1;
+  for (const m of messages) {
+    if (isOptimistic(m))
+      continue;
+    if (m.seq > lastSeq)
+      lastSeq = m.seq;
+  }
+  return activity.filter((a) => a.seq > lastSeq);
+}
+function turnIsRunning(messages, activity) {
+  if (messages.some(isOptimistic))
+    return true;
+  return activity.isProcessing || activity.hasPendingTurn;
+}
+function mergePlans(existing, incoming) {
+  const bySeq = new Map;
+  for (const plan of existing)
+    bySeq.set(plan.seq, plan);
+  for (const plan of incoming)
+    bySeq.set(plan.seq, plan);
+  return [...bySeq.values()].sort((a, b) => a.seq - b.seq);
+}
+function planOf(message, messages, plans) {
+  if (message.role !== "agent" || plans.length === 0)
+    return null;
+  let previousSeq = -1;
+  for (const m of messages) {
+    if (m.seq >= message.seq)
+      break;
+    previousSeq = m.seq;
+  }
+  let found = null;
+  for (const plan of plans) {
+    if (plan.seq > previousSeq && plan.seq < message.seq)
+      found = plan.todos;
+  }
+  return found;
+}
+function planAfterLast(messages, plans) {
+  if (plans.length === 0)
+    return null;
+  let lastSeq = -1;
+  for (const m of messages) {
+    if (isOptimistic(m))
+      continue;
+    if (m.seq > lastSeq)
+      lastSeq = m.seq;
+  }
+  let found = null;
+  for (const plan of plans) {
+    if (plan.seq > lastSeq)
+      found = plan.todos;
+  }
+  return found;
+}
+function useConversation(conversationId, options = {}) {
+  const pageSize = options.pageSize ?? 50;
+  const { agentSlug } = options;
+  const declareTools = options.declareClientTools ?? true;
+  const client = useAgentClient();
+  const [conversation, setConversation] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [toolActivity, setToolActivity] = useState([]);
+  const [plans, setPlans] = useState([]);
+  const [todos, setTodos] = useState([]);
+  const [activity, setActivity] = useState(IDLE);
+  const [isLoading, setIsLoading] = useState(conversationId !== null);
+  const [error, setError] = useState(null);
+  const [isSending, setIsSending] = useState(false);
+  const [hasOlder, setHasOlder] = useState(false);
+  const [isLoadingOlder, setIsLoadingOlder] = useState(false);
+  const [workspaceRevision, setWorkspaceRevision] = useState(0);
+  const onCreated = useRef2(options.onCreated);
+  onCreated.current = options.onCreated;
+  const adopting = useRef2(null);
+  const oldestSeq = useRef2(null);
+  const loadingOlder = useRef2(false);
+  const cursor = useRef2(null);
+  const hasOlderRef = useRef2(false);
+  const pendingIds = useRef2(new Set);
+  const clientTools = useRef2(options.clientTools);
+  clientTools.current = options.clientTools;
+  const components = useRef2(options.components);
+  components.current = options.components;
+  const onClientToolError = useRef2(options.onClientToolError);
+  onClientToolError.current = options.onClientToolError;
+  const heldContext = useRef2(undefined);
+  const sentContext = useRef2(null);
+  const isTurnRunningRef = useRef2(false);
+  const flushContext = useCallback(async (id) => {
+    const held = heldContext.current;
+    if (held === undefined)
+      return;
+    const sent = sentContext.current;
+    if (sent?.id === id && sent.value === held)
+      return;
+    sentContext.current = { id, value: held };
+    try {
+      await client.setContext(id, held);
+    } catch {
+      sentContext.current = null;
+    }
+  }, [client]);
+  useEffect(() => {
+    heldContext.current = options.context;
+    if (conversationId !== null && isTurnRunningRef.current)
+      flushContext(conversationId);
+  }, [options.context, conversationId, flushContext]);
+  const toolsKey = useMemo2(() => stableKey(options.clientTools), [options.clientTools]);
+  const handlers = useRef2({});
+  const declaredKey = useRef2(null);
+  useEffect(() => {
+    Object.assign(handlers.current, options.clientTools ?? {});
+  }, [options.clientTools]);
+  const flushClientTools = useCallback(async (id) => {
+    if (!declareTools || toolsKey === null)
+      return;
+    const last = declaredKey.current;
+    if (last?.id === id && last.key === toolsKey)
+      return;
+    declaredKey.current = { id, key: toolsKey };
+    try {
+      await client.setClientTools(id, clientTools.current ?? {});
+    } catch (err) {
+      declaredKey.current = null;
+      onClientToolError.current?.(err);
+    }
+  }, [client, declareTools, toolsKey]);
+  const syncClientTools = useCallback(async () => {
+    if (conversationId !== null)
+      await flushClientTools(conversationId);
+  }, [conversationId, flushClientTools]);
+  const libraries = useRef2(options.componentLibraries);
+  libraries.current = options.componentLibraries;
+  const librariesKey = options.componentLibraries === undefined ? null : JSON.stringify(options.componentLibraries);
+  const toolSession = useRef2(null);
+  const registered = useRef2(null);
+  useEffect(() => {
+    const adopted = conversationId !== null && conversationId === adopting.current;
+    adopting.current = null;
+    if (!adopted) {
+      setConversation(null);
+      setMessages([]);
+      setToolActivity([]);
+      setTodos([]);
+      setPlans([]);
+      setActivity(IDLE);
+      pendingIds.current.clear();
+    }
+    setError(null);
+    setHasOlder(false);
+    setIsLoadingOlder(false);
+    oldestSeq.current = null;
+    loadingOlder.current = false;
+    cursor.current = null;
+    hasOlderRef.current = false;
+    if (conversationId === null) {
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    const controller = new AbortController;
+    let subscription = null;
+    let closed = false;
+    (async () => {
+      try {
+        const page = await client.loadHistory(conversationId, {
+          pageSize,
+          signal: controller.signal
+        });
+        if (controller.signal.aborted)
+          return;
+        setMessages((prev) => mergeMessages(prev, page.messages));
+        setToolActivity((prev) => mergeToolActivities([...prev, ...page.toolActivity]));
+        setPlans((prev) => mergePlans(prev, page.plans));
+        oldestSeq.current = page.oldestSeq;
+        cursor.current = page.latestChangeSeq;
+        hasOlderRef.current = page.hasOlder;
+        setHasOlder(page.hasOlder);
+        setIsLoading(false);
+        if (closed)
+          return;
+        subscription = client.subscribe(conversationId, {
+          onOpen: () => toolSession.current?.poke(),
+          onClientToolCall: () => toolSession.current?.poke(),
+          onEvent: (event) => {
+            if (event.type === "workspace_root")
+              setWorkspaceRevision((n) => n + 1);
+          },
+          onToolActivity: (activity2) => {
+            setToolActivity((prev) => mergeToolActivities([...prev, activity2]));
+          },
+          onMessage: (message) => {
+            pendingIds.current.delete(optimisticIdFor(message));
+            setMessages((prev) => mergeMessages(dropOptimisticEcho(prev, message), [message]));
+            setIsLoading(false);
+          },
+          onTodos: (todos2, seq) => {
+            setTodos(todos2);
+            setPlans((prev) => mergePlans(prev, [{ todos: todos2, seq }]));
+          },
+          onActivity: setActivity,
+          onConversation: setConversation,
+          onCursor: (changeSeq) => {
+            if (cursor.current === null || changeSeq > cursor.current) {
+              cursor.current = changeSeq;
+            }
+          }
+        }, { since: page.latestChangeSeq ?? undefined });
+      } catch (err) {
+        if (controller.signal.aborted)
+          return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setIsLoading(false);
+      }
+    })();
+    return () => {
+      closed = true;
+      controller.abort();
+      subscription?.close();
+    };
+  }, [client, conversationId, pageSize]);
+  const snapshot = useRef2({
+    messages,
+    toolActivity,
+    plans,
+    oldestSeq,
+    cursor,
+    hasOlderRef
+  });
+  snapshot.current.messages = messages;
+  snapshot.current.toolActivity = toolActivity;
+  snapshot.current.plans = plans;
+  const persist = useCallback((id) => {
+    const { messages: held, toolActivity: trail, plans: planned } = snapshot.current;
+    client.saveHistory(id, {
+      toolActivity: trail,
+      plans: planned,
+      messages: held.filter((m) => !m.id.startsWith("optimistic:")),
+      oldestSeq: oldestSeq.current,
+      latestChangeSeq: cursor.current,
+      hasOlder: hasOlderRef.current
+    });
+  }, [client]);
+  useEffect(() => {
+    if (conversationId === null || messages.length === 0)
+      return;
+    const timer = setTimeout(() => persist(conversationId), 400);
+    return () => clearTimeout(timer);
+  }, [conversationId, messages, persist]);
+  useEffect(() => {
+    if (conversationId === null)
+      return;
+    return () => persist(conversationId);
+  }, [conversationId, persist]);
+  useEffect(() => {
+    const current = libraries.current;
+    if (conversationId === null || librariesKey === null || current === undefined)
+      return;
+    const stamp = `${conversationId}\x00${librariesKey}`;
+    if (registered.current === stamp)
+      return;
+    const controller = new AbortController;
+    client.setComponentLibraries(conversationId, current, controller.signal).then((enabled) => {
+      registered.current = stamp;
+      warnMissingRenderers(enabled.tags, components.current);
+    }).catch((err) => {
+      if (controller.signal.aborted)
+        return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+    });
+    return () => controller.abort();
+  }, [client, conversationId, librariesKey]);
+  const servesTools = options.clientTools !== undefined;
+  const flushToolsRef = useRef2(flushClientTools);
+  flushToolsRef.current = flushClientTools;
+  useEffect(() => {
+    if (conversationId === null || !servesTools)
+      return;
+    let session = null;
+    let cancelled = false;
+    (async () => {
+      try {
+        const started = await client.serveClientTools(conversationId, {
+          tools: handlers.current,
+          watch: false,
+          declare: false,
+          onError: (err) => onClientToolError.current?.(err)
+        });
+        flushToolsRef.current(conversationId);
+        if (cancelled) {
+          started.stop();
+          return;
+        }
+        session = started;
+        toolSession.current = started;
+        started.poke();
+      } catch (err) {
+        if (!cancelled)
+          onClientToolError.current?.(err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      toolSession.current = null;
+      session?.stop();
+    };
+  }, [client, conversationId, servesTools]);
+  const loadOlder = useCallback(async () => {
+    if (conversationId === null || loadingOlder.current)
+      return 0;
+    const before = oldestSeq.current;
+    if (before === null)
+      return 0;
+    loadingOlder.current = true;
+    setIsLoadingOlder(true);
+    try {
+      const page = await client.listMessagesPage(conversationId, {
+        before,
+        limit: pageSize
+      });
+      setMessages((prev) => mergeMessages(prev, page.messages));
+      setToolActivity((prev) => mergeToolActivities([...prev, ...page.toolActivity]));
+      setPlans((prev) => mergePlans(prev, page.plans));
+      if (page.oldestSeq !== null)
+        oldestSeq.current = page.oldestSeq;
+      hasOlderRef.current = page.hasOlder;
+      setHasOlder(page.hasOlder);
+      return page.messages.length;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return 0;
+    } finally {
+      loadingOlder.current = false;
+      setIsLoadingOlder(false);
+    }
+  }, [client, conversationId, pageSize]);
+  const target = useCallback(async () => {
+    if (conversationId !== null)
+      return conversationId;
+    const created = await client.createConversation({
+      agentSlug,
+      ...libraries.current === undefined ? {} : { componentLibraries: libraries.current }
+    });
+    if (libraries.current !== undefined && librariesKey !== null) {
+      registered.current = `${created.id}\x00${librariesKey}`;
+      client.listComponentLibraries(created.id).then((enabled) => warnMissingRenderers(enabled.tags, components.current)).catch(() => {});
+    }
+    if (clientTools.current !== undefined && declareTools) {
+      await client.setClientTools(created.id, clientTools.current);
+    }
+    adopting.current = created.id;
+    setConversation(created);
+    await onCreated.current?.(created);
+    return created.id;
+  }, [client, conversationId, agentSlug, librariesKey, declareTools]);
+  const send = useCallback(async (content) => {
+    const text = content.trim();
+    if (!text)
+      return;
+    const optimistic = {
+      id: `optimistic:${text}`,
+      role: "user",
+      content: text,
+      attachments: [],
+      seq: Number.MAX_SAFE_INTEGER,
+      at: new Date().toISOString()
+    };
+    pendingIds.current.add(optimistic.id);
+    setMessages((prev) => mergeMessages(prev, [optimistic]));
+    setIsSending(true);
+    setError(null);
+    setActivity((prev) => ({ ...prev, hasPendingTurn: true }));
+    try {
+      const id = await target();
+      await flushContext(id);
+      await flushClientTools(id);
+      await client.sendMessage(id, text);
+    } catch (err) {
+      pendingIds.current.delete(optimistic.id);
+      setMessages((prev) => prev.filter((m) => m.id !== optimistic.id));
+      setActivity((prev) => ({ ...prev, hasPendingTurn: false }));
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      setError(wrapped);
+      throw wrapped;
+    } finally {
+      setIsSending(false);
+    }
+  }, [client, target, flushContext, flushClientTools]);
+  const sendAudio = useCallback(async (audio) => {
+    if (audio.size === 0)
+      return;
+    setIsSending(true);
+    setError(null);
+    setActivity((prev) => ({ ...prev, hasPendingTurn: true }));
+    try {
+      const id = await target();
+      await flushContext(id);
+      await flushClientTools(id);
+      await client.sendAudio(id, audio);
+    } catch (err) {
+      setActivity((prev) => ({ ...prev, hasPendingTurn: false }));
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      setError(wrapped);
+      throw wrapped;
+    } finally {
+      setIsSending(false);
+    }
+  }, [client, target, flushContext, flushClientTools]);
+  const sendImages = useCallback(async (images, caption) => {
+    if (images.length === 0)
+      return;
+    setIsSending(true);
+    setError(null);
+    setActivity((prev) => ({ ...prev, hasPendingTurn: true }));
+    try {
+      const id = await target();
+      await flushContext(id);
+      await flushClientTools(id);
+      await client.sendImages(id, images, { caption });
+    } catch (err) {
+      setActivity((prev) => ({ ...prev, hasPendingTurn: false }));
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      setError(wrapped);
+      throw wrapped;
+    } finally {
+      setIsSending(false);
+    }
+  }, [client, target, flushContext, flushClientTools]);
+  const listFiles = useCallback(async (path) => {
+    if (conversationId === null)
+      return [];
+    const dir = await client.listFiles(conversationId, { path });
+    return dir.entries;
+  }, [client, conversationId]);
+  const readFile = useCallback(async (path) => {
+    if (conversationId === null) {
+      throw new Error("There is no conversation yet, so there are no files to read.");
+    }
+    return await client.readFile(conversationId, path);
+  }, [client, conversationId]);
+  const writeFiles = useCallback(async (files) => {
+    if (files.length === 0)
+      return;
+    const id = await target();
+    await client.writeFiles(id, files);
+    setWorkspaceRevision((n) => n + 1);
+  }, [client, target]);
+  const deleteFile = useCallback(async (path) => {
+    if (conversationId === null)
+      return;
+    await client.deleteFile(conversationId, path);
+    setWorkspaceRevision((n) => n + 1);
+  }, [client, conversationId]);
+  const moveFile = useCallback(async (from, to) => {
+    if (conversationId === null)
+      return;
+    await client.moveFile(conversationId, from, to);
+    setWorkspaceRevision((n) => n + 1);
+  }, [client, conversationId]);
+  const steer = useCallback(async (content) => {
+    const text = content.trim();
+    if (!text || conversationId === null)
+      return;
+    await client.steer(conversationId, text);
+  }, [client, conversationId]);
+  const trailFor = useCallback((message) => trailOf(message, messages, toolActivity), [messages, toolActivity]);
+  const pendingTrail = useMemo2(() => trailAfterLast(messages, toolActivity), [messages, toolActivity]);
+  const planFor = useCallback((message) => planOf(message, messages, plans), [messages, plans]);
+  const pendingPlan = useMemo2(() => planAfterLast(messages, plans), [messages, plans]);
+  const isTurnRunning = useMemo2(() => turnIsRunning(messages, activity), [messages, activity]);
+  isTurnRunningRef.current = isTurnRunning;
+  const renderMessage = useCallback((message) => renderBlocks(message, {
+    components: components.current,
+    renderMarkdown: options.renderMarkdown,
+    wrapBlock: options.wrapBlock
+  }), [options.renderMarkdown, options.wrapBlock]);
+  return useMemo2(() => ({
+    conversation,
+    messages,
+    toolActivity,
+    trailFor,
+    pendingTrail,
+    planFor,
+    pendingPlan,
+    todos,
+    activity,
+    isTurnRunning,
+    isLoading,
+    hasOlder,
+    isLoadingOlder,
+    loadOlder,
+    error,
+    send,
+    sendAudio,
+    sendImages,
+    steer,
+    isSending,
+    renderMessage,
+    syncClientTools,
+    workspaceRevision,
+    listFiles,
+    readFile,
+    writeFiles,
+    deleteFile,
+    moveFile
+  }), [
+    conversation,
+    messages,
+    toolActivity,
+    trailFor,
+    pendingTrail,
+    planFor,
+    pendingPlan,
+    todos,
+    activity,
+    isTurnRunning,
+    isLoading,
+    hasOlder,
+    isLoadingOlder,
+    loadOlder,
+    error,
+    send,
+    sendAudio,
+    sendImages,
+    steer,
+    isSending,
+    renderMessage,
+    syncClientTools,
+    workspaceRevision,
+    listFiles,
+    readFile,
+    writeFiles,
+    deleteFile,
+    moveFile
+  ]);
+}
+function optimisticIdFor(message) {
+  return `optimistic:${message.content.trim()}`;
+}
+function dropOptimisticEcho(messages, real) {
+  if (real.role !== "user")
+    return messages;
+  const echoId = optimisticIdFor(real);
+  return messages.filter((m) => m.id !== echoId);
+}
+function warnMissingRenderers(tags, components) {
+  const missing = tags.filter((tag) => components?.[tag] === undefined);
+  if (missing.length === 0)
+    return;
+  console.warn(`[cubos-agent] The enabled component libraries offer ${missing.map((t) => `<${t}>`).join(", ")}, which this app has no renderer for. The agent may use them ` + "and nothing will be drawn. Add them to `components`, or drop the library " + "that declares them from `componentLibraries`.");
+}
+function stableKey(tools) {
+  if (tools === undefined)
+    return null;
+  return JSON.stringify(Object.entries(tools).map(([name, tool]) => [
+    name,
+    tool.description,
+    tool.inputSchema,
+    tool.outputSchema,
+    tool.readOnlyHint,
+    tool.destructiveHint,
+    tool.idempotentHint,
+    tool.timeoutSeconds
+  ]));
+}
+// src/use-conversation-events.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef3, useState as useState2 } from "react";
+function useConversationEvents(conversationId, options = {}) {
+  const client = useAgentClient();
+  const pageSize = options.pageSize ?? 50;
+  const [events, setEvents] = useState2([]);
+  const [initialLoaded, setInitialLoaded] = useState2(false);
+  const [hasOlder, setHasOlder] = useState2(false);
+  const [isLoadingOlder, setIsLoadingOlder] = useState2(false);
+  const [activity, setActivity] = useState2(IDLE2);
+  const oldestSeq = useRef3(null);
+  const loadingOlder = useRef3(false);
+  const onEvent = useRef3(options.onEvent);
+  onEvent.current = options.onEvent;
+  useEffect2(() => {
+    setEvents([]);
+    setInitialLoaded(false);
+    setHasOlder(false);
+    setIsLoadingOlder(false);
+    setActivity(IDLE2);
+    oldestSeq.current = null;
+    loadingOlder.current = false;
+    if (conversationId === null)
+      return;
+    const controller = new AbortController;
+    let subscription = null;
+    let closed = false;
+    (async () => {
+      try {
+        const page = await client.listEventsPage(conversationId, {
+          limit: pageSize,
+          signal: controller.signal
+        });
+        if (controller.signal.aborted)
+          return;
+        setEvents(page.events);
+        oldestSeq.current = page.oldestSeq;
+        setHasOlder(page.hasOlder);
+        setInitialLoaded(true);
+        if (closed)
+          return;
+        subscription = client.subscribe(conversationId, {
+          onEvent: (event) => {
+            setEvents((prev) => upsert(prev, event));
+            onEvent.current?.(event);
+          },
+          onActivity: setActivity
+        }, { since: page.latestChangeSeq ?? undefined });
+      } catch {
+        if (!controller.signal.aborted)
+          setInitialLoaded(true);
+      }
+    })();
+    return () => {
+      closed = true;
+      controller.abort();
+      subscription?.close();
+    };
+  }, [client, conversationId, pageSize]);
+  const loadOlder = useCallback2(async () => {
+    const before = oldestSeq.current;
+    if (conversationId === null || before === null)
+      return 0;
+    if (loadingOlder.current || !hasOlder)
+      return 0;
+    loadingOlder.current = true;
+    setIsLoadingOlder(true);
+    try {
+      const page = await client.listEventsPage(conversationId, { before, limit: pageSize });
+      if (page.events.length === 0) {
+        setHasOlder(false);
+        return 0;
+      }
+      let added = 0;
+      setEvents((prev) => {
+        const held = new Set(prev.map((e) => e.id));
+        const fresh = page.events.filter((e) => !held.has(e.id));
+        added = fresh.length;
+        return [...fresh, ...prev];
+      });
+      oldestSeq.current = page.oldestSeq ?? before;
+      setHasOlder(page.hasOlder);
+      return added;
+    } catch {
+      return 0;
+    } finally {
+      loadingOlder.current = false;
+      setIsLoadingOlder(false);
+    }
+  }, [client, conversationId, hasOlder, pageSize]);
+  return { events, initialLoaded, hasOlder, isLoadingOlder, loadOlder, activity };
+}
+var IDLE2 = { isProcessing: false, hasPendingTurn: false };
+function upsert(held, incoming) {
+  const at = held.findIndex((e) => e.id === incoming.id);
+  if (at >= 0) {
+    const next2 = held.slice();
+    next2[at] = incoming;
+    return next2;
+  }
+  const next = [...held, incoming];
+  next.sort((a, b) => a.seq - b.seq);
+  return next;
+}
+// src/use-conversation-list.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef4, useState as useState3 } from "react";
+function upsert2(list, incoming) {
+  const next = list.filter((c) => c.id !== incoming.id);
+  next.push(incoming);
+  return next.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
+}
+function useConversationList(opts = {}) {
+  const client = useAgentClient();
+  const pageSize = opts.pageSize ?? 30;
+  const [conversations, setConversations] = useState3([]);
+  const [isLoading, setIsLoading] = useState3(true);
+  const [isLoadingMore, setIsLoadingMore] = useState3(false);
+  const [error, setError] = useState3(null);
+  const cursor = useRef4(null);
+  const [hasMore, setHasMore] = useState3(false);
+  useEffect3(() => {
+    const controller = new AbortController;
+    setIsLoading(true);
+    client.listConversations({ limit: pageSize, signal: controller.signal }).then((page) => {
+      if (controller.signal.aborted)
+        return;
+      setConversations(page.items);
+      cursor.current = page.nextCursor;
+      setHasMore(page.nextCursor !== null);
+      setIsLoading(false);
+    }).catch((err) => {
+      if (controller.signal.aborted)
+        return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setIsLoading(false);
+    });
+    const subscription = client.subscribeToConversations({
+      onConversation: (conversation) => {
+        setConversations((prev) => conversation.archived ? prev.filter((c) => c.id !== conversation.id) : upsert2(prev, conversation));
+      }
+    });
+    return () => {
+      controller.abort();
+      subscription.close();
+    };
+  }, [client, pageSize]);
+  const loadMore = useCallback3(async () => {
+    if (cursor.current === null)
+      return;
+    setIsLoadingMore(true);
+    try {
+      const page = await client.listConversations({ limit: pageSize, before: cursor.current });
+      setConversations((prev) => {
+        const seen = new Set(prev.map((c) => c.id));
+        return [...prev, ...page.items.filter((c) => !seen.has(c.id))];
+      });
+      cursor.current = page.nextCursor;
+      setHasMore(page.nextCursor !== null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoadingMore(false);
+    }
+  }, [client, pageSize]);
+  const create = useCallback3(async (createOpts = {}) => {
+    const conversation = await client.createConversation(createOpts);
+    setConversations((prev) => upsert2(prev, conversation));
+    return conversation;
+  }, [client]);
+  const archive = useCallback3(async (id) => {
+    await client.archiveConversation(id);
+    setConversations((prev) => prev.filter((c) => c.id !== id));
+  }, [client]);
+  return {
+    conversations,
+    isLoading,
+    isLoadingMore,
+    error,
+    hasMore,
+    loadMore,
+    create,
+    archive
+  };
+}
+// src/use-identity.ts
+import { useEffect as useEffect4, useState as useState4 } from "react";
+function useIdentity() {
+  const client = useAgentClient();
+  const [identity, setIdentity] = useState4(null);
+  const [isLoading, setIsLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  useEffect4(() => {
+    let active = true;
+    setIsLoading(true);
+    setError(null);
+    client.me().then((next) => {
+      if (!active)
+        return;
+      setIdentity(next);
+      setIsLoading(false);
+    }).catch((err) => {
+      if (!active)
+        return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setIsLoading(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [client]);
+  return { identity, isLoading, error };
+}
+export {
+  useIdentity,
+  useConversationList,
+  useConversationEvents,
+  useConversation,
+  useAgentClient,
+  renderBlocks,
+  AgentProvider
+};
+
+//# debugId=54F834B7C1AC034364756E2164756E21
+//# sourceMappingURL=index.js.map