@agents24/react 0.1.0

package/dist/index.js

@@ -0,0 +1,707 @@
+// src/lifecycle.ts
+function createPortableId() {
+  const cryptoLike = globalThis.crypto;
+  if (cryptoLike?.randomUUID) return cryptoLike.randomUUID();
+  return `a24-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function isAbortLike(error) {
+  if (!error || typeof error !== "object") return false;
+  const input = error;
+  return input.name === "AbortError" || input.kind === "aborted" || input.code === "ABORTED";
+}
+
+// src/model.ts
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var text = (value) => typeof value === "string" && value.trim() ? value : null;
+var statusToToolState = (value) => {
+  const normalized = String(value || "").toLowerCase();
+  if (normalized === "failed" || normalized === "error") return "output-error";
+  if (normalized === "cancelled" || normalized === "canceled") return "cancelled";
+  if (["complete", "completed", "done", "success"].includes(normalized)) return "output-available";
+  return normalized === "streaming" ? "input-streaming" : "input-available";
+};
+var allowedActions = {
+  tool_review: ["approve", "reject"],
+  mcp_auth: ["connect", "skip"],
+  user_approval: ["approve", "reject"],
+  app_data_permission: ["approve", "reject"]
+};
+function partsFromResponseBlocks(blocks, fallbackText = "") {
+  const input = Array.isArray(blocks) ? blocks : [];
+  const parts = input.flatMap((item, index) => {
+    const block = record(item);
+    if (!block) return [];
+    const kind = String(block.kind || "data");
+    const id = String(block.id || `${kind}-${index}`);
+    if (kind === "assistant_text") {
+      const value = text(block.text);
+      return value ? [{ id, type: "text", kind: "text", text: value, raw: block }] : [];
+    }
+    if (kind === "tool" || kind === "tool_call" || kind === "tool_result") {
+      const tool = record(block.tool) || block;
+      const toolName = String(tool.action || tool.title || "tool");
+      return [{
+        id,
+        type: `tool-${toolName}`,
+        kind: "tool",
+        toolName,
+        toolCallId: text(tool.toolCallId),
+        state: statusToToolState(block.status),
+        input: tool.input,
+        output: tool.output,
+        errorText: text(tool.error || block.error),
+        presentation: record(tool.presentation),
+        raw: block
+      }];
+    }
+    if (kind === "reasoning_note") return [{ id, type: "reasoning", kind: "reasoning", label: text(block.label), text: text(block.description), status: text(block.status), raw: block }];
+    if (kind === "ui_blocks") return [{ id, type: "ui-blocks", kind: "ui-blocks", state: statusToToolState(block.status), toolCallId: text(block.toolCallId), contractVersion: text(block.contractVersion), bundle: record(block.bundle), errorText: text(block.error), raw: block }];
+    if (kind === "hitl_request") {
+      const hitl = record(block.hitl) || {};
+      const hitlKind = String(block.hitlKind || hitl.kind || "");
+      if (!(hitlKind in allowedActions)) return [];
+      const actions = Array.isArray(hitl.allowed_actions) ? hitl.allowed_actions.map(String) : [];
+      const expected = allowedActions[hitlKind];
+      if (actions.length !== expected.length || actions.some((action, actionIndex) => action !== expected[actionIndex])) return [];
+      return [{
+        id,
+        type: "hitl",
+        kind: "hitl",
+        interruptId: String(block.interruptId || hitl.interrupt_id || ""),
+        hitlKind,
+        message: String(block.text || hitl.message || ""),
+        allowedActions: actions,
+        status: String(block.status || "pending"),
+        presentation: record(hitl.presentation) || hitl,
+        resolution: record(block.resolution),
+        raw: block
+      }];
+    }
+    if (kind === "error") return [{ id, type: "error", kind: "error", errorText: String(record(block.error)?.message || block.text || "The run failed."), raw: block }];
+    if (kind === "source") return [{ id, type: "source", kind: "source", title: String(block.title || "Source"), url: text(block.url), description: text(block.description), raw: block }];
+    if (kind === "citation") return [{ id, type: "citation", kind: "citation", sourceId: text(block.sourceId), label: text(block.label), url: text(block.url), raw: block }];
+    if (kind === "attachment") {
+      const attachment = record(block.attachment) || {};
+      return [{ id, type: "attachment", kind: "attachment", attachment: { ...attachment, id: text(attachment.id) || void 0, filename: text(attachment.name) || "Attachment", mediaType: text(attachment.mime_type) || void 0 }, raw: block }];
+    }
+    return [{ id, type: "data", kind: "data", name: kind, data: block, raw: block }];
+  });
+  if (!parts.some((part) => part.kind === "text") && fallbackText.trim()) {
+    parts.push({ id: "assistant-text", type: "text", kind: "text", text: fallbackText.trim() });
+  }
+  return parts;
+}
+function assistantProjectionFromEvent(event) {
+  const payload = record(event.payload) || {};
+  const content = text(payload.assistant_output_text) || "";
+  const fromBlocks = partsFromResponseBlocks(payload.response_blocks, content);
+  if (fromBlocks.length) return { content, parts: fromBlocks };
+  if (event.event === "reasoning.update") return {
+    content,
+    parts: [{ id: `reasoning-${event.seq}`, type: "reasoning", kind: "reasoning", label: text(payload.label), text: text(payload.description), status: text(payload.status), raw: payload }]
+  };
+  if (event.event === "ui_blocks.updated") return {
+    content,
+    parts: [{ id: `ui-blocks-${event.seq}`, type: "ui-blocks", kind: "ui-blocks", state: "input-available", bundle: record(payload.bundle), raw: payload }]
+  };
+  if (event.event === "runtime.error") return {
+    content,
+    parts: [{ id: `error-${event.seq}`, type: "error", kind: "error", errorText: String(record(payload.error)?.message || "The run failed."), raw: payload }]
+  };
+  if ((event.event === "source.added" || event.event === "citation.added") && record(payload.source)) {
+    return { content, parts: partsFromResponseBlocks([payload.source]) };
+  }
+  if (event.event === "tool.started") {
+    const toolName = String(payload.display_name || "Tool");
+    return {
+      content,
+      parts: [{ id: String(payload.tool_call_id || `tool-${event.seq}`), type: `tool-${toolName}`, kind: "tool", toolName, toolCallId: text(payload.tool_call_id), state: "input-available", presentation: { title: toolName }, raw: payload }]
+    };
+  }
+  if (event.event === "hitl.requested") {
+    const hitl = record(payload.hitl) || {};
+    const kind = String(hitl.kind || "");
+    const actions = Array.isArray(hitl.allowed_actions) ? hitl.allowed_actions.map(String) : [];
+    if (kind in allowedActions && actions.length === allowedActions[kind].length && actions.every((action, index) => action === allowedActions[kind][index])) {
+      return {
+        content,
+        parts: [{ id: `hitl-${event.seq}`, type: "hitl", kind: "hitl", interruptId: String(hitl.interrupt_id || ""), hitlKind: kind, message: String(hitl.message || ""), allowedActions: actions, status: "pending", presentation: record(hitl.presentation) || hitl, raw: payload }]
+      };
+    }
+  }
+  return { content, parts: [] };
+}
+function threadDetailToMessages(detail) {
+  return (detail.turns || []).flatMap((item, index) => {
+    const turn = record(item) || {};
+    const userText = text(turn.user_input_text) || "";
+    const assistantText = text(turn.assistant_output_text) || "";
+    const runId = text(turn.run_id);
+    const createdAt = text(turn.created_at) || (/* @__PURE__ */ new Date(0)).toISOString();
+    const attachments = Array.isArray(turn.attachments) ? turn.attachments.flatMap((attachment) => record(attachment) ? [record(attachment)] : []) : [];
+    const output = [];
+    if (userText || attachments.length) output.push({
+      id: String(turn.id || `${runId || index}-user`),
+      role: "user",
+      content: userText,
+      createdAt,
+      parts: userText ? [{ id: `${runId || index}-user-text`, type: "text", kind: "text", text: userText }] : [],
+      attachments,
+      messageIndex: typeof turn.turn_index === "number" ? turn.turn_index : index
+    });
+    if (assistantText || Array.isArray(turn.response_blocks)) output.push({
+      id: `${runId || turn.id || index}-assistant`,
+      role: "assistant",
+      runId,
+      content: assistantText,
+      createdAt: text(turn.completed_at) || createdAt,
+      isFinal: !["queued", "running", "paused", "cancelling"].includes(String(turn.status || "").toLowerCase()),
+      parts: partsFromResponseBlocks(turn.response_blocks, assistantText),
+      messageIndex: typeof turn.turn_index === "number" ? turn.turn_index : index
+    });
+    return output;
+  });
+}
+function attachmentResultToChatAttachment(result) {
+  return { ...result, id: result.id, filename: result.filename, mediaType: result.mime_type, status: result.status };
+}
+
+// src/provider.tsx
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+var Agents24Context = React.createContext(null);
+function Agents24Provider({
+  children,
+  client,
+  createAbortController,
+  createId = createPortableId,
+  storage
+}) {
+  const value = React.useMemo(
+    () => ({ client, createAbortController, createId, storage }),
+    [client, createAbortController, createId, storage]
+  );
+  return /* @__PURE__ */ jsx(Agents24Context.Provider, { value, children });
+}
+function useAgents24Runtime() {
+  const value = React.useContext(Agents24Context);
+  if (!value) throw new Error("Agents24 hooks must be rendered inside Agents24Provider.");
+  return value;
+}
+function useAgentClient() {
+  return useAgents24Runtime().client;
+}
+
+// src/state.ts
+var initialAgentChatState = {
+  threads: [],
+  activeThreadId: null,
+  messages: [],
+  activeRunId: null,
+  cursor: null,
+  streamingMessageId: null,
+  runState: "idle",
+  error: null
+};
+function appendStableStreamingTurn(messages, userMessage, assistantMessage) {
+  const next = [...messages];
+  if (!next.some((message) => message.id === userMessage.id)) next.push(userMessage);
+  if (!next.some((message) => message.id === assistantMessage.id || Boolean(
+    assistantMessage.runId && message.role === "assistant" && message.runId === assistantMessage.runId
+  ))) next.push(assistantMessage);
+  return next;
+}
+function upsertStableAssistantMessage(messages, input) {
+  const next = [...messages];
+  for (const baseMessage of input.baseMessages || []) {
+    const isTarget = baseMessage.role === "assistant" && (Boolean(input.messageId && baseMessage.id === input.messageId) || Boolean(input.runId && baseMessage.runId === input.runId));
+    if (!isTarget && !next.some((message) => message.id === baseMessage.id)) next.push(baseMessage);
+  }
+  const index = next.findIndex((message) => message.role === "assistant" && (Boolean(input.messageId && message.id === input.messageId) || Boolean(input.runId && message.runId === input.runId)));
+  if (index === -1) next.push(input.create());
+  else next[index] = input.update(next[index]);
+  return next;
+}
+function applyRuntimeEvent(state, event) {
+  const projection = assistantProjectionFromEvent(event);
+  const eventName = String(event.event || "");
+  const runId = event.run_id || state.activeRunId;
+  const messageId = state.streamingMessageId || `${runId || "run"}-assistant`;
+  const terminal = eventName === "run.completed" || eventName === "run.failed" || eventName === "run.cancelled";
+  const paused = eventName === "run.paused" || projection.parts.some((part) => part.kind === "hitl" && part.status === "pending");
+  const existing = state.messages.find((message) => message.id === messageId || Boolean(runId && message.runId === runId));
+  const payload = event.payload || {};
+  const delta = eventName === "assistant.delta" && typeof payload.content === "string" ? payload.content : "";
+  const content = delta ? `${existing?.content || ""}${delta}` : projection.content || existing?.content || "";
+  const deltaParts = delta ? [{ id: `${runId || "run"}-assistant-text`, type: "text", kind: "text", text: content }] : [];
+  const incomingParts = projection.parts.length ? projection.parts : deltaParts;
+  const parts = incomingParts.length ? [...(existing?.parts || []).filter((part) => !incomingParts.some((incoming) => incoming.id === part.id || incoming.kind === "text" && part.kind === "text")), ...incomingParts] : existing?.parts || [];
+  return {
+    ...state,
+    activeRunId: terminal ? null : runId,
+    cursor: typeof event.seq === "number" ? event.seq : state.cursor,
+    messages: upsertStableAssistantMessage(state.messages, {
+      messageId,
+      runId,
+      create: () => ({
+        id: messageId,
+        role: "assistant",
+        runId,
+        content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        isFinal: terminal,
+        parts
+      }),
+      update: (message) => ({
+        ...message,
+        runId: runId ?? message.runId,
+        content,
+        parts,
+        isFinal: terminal || message.isFinal
+      })
+    }),
+    runState: paused ? "paused" : terminal ? eventName === "run.completed" ? "completed" : "failed" : "streaming",
+    streamingMessageId: terminal || paused ? null : messageId
+  };
+}
+function applyThreadSummaryEvent(threads, event) {
+  if (event.event === "snapshot_required") return threads;
+  if (event.event === "thread.deleted") return threads.filter((thread) => thread.id !== event.thread_id);
+  if (event.event !== "thread.summary.updated") return threads;
+  const incoming = event.thread;
+  const index = threads.findIndex((thread) => thread.id === incoming.id);
+  if (index === -1) return [{ ...incoming, messages: incoming.messages || [], isHydrated: false }, ...threads];
+  const next = [...threads];
+  next[index] = { ...next[index], ...incoming, messages: next[index].messages, isHydrated: next[index].isHydrated };
+  return next;
+}
+
+// src/use-agent-chat.ts
+import * as React2 from "react";
+function summaryToStored(thread) {
+  return { ...thread, id: String(thread.id), messages: [], isHydrated: false };
+}
+function activeRunIdFromThread(thread) {
+  if (!thread) return null;
+  const active = thread.active_run;
+  const status = String(active?.status || thread.last_run_status || "").toLowerCase();
+  if (!["queued", "running", "cancelling"].includes(status)) return null;
+  return String(active?.run_id || thread.last_run_id || "") || null;
+}
+function useAgentChat(options = {}) {
+  const runtime = useAgents24Runtime();
+  const client = options.client || runtime.client;
+  const pageSize = options.pageSize ?? 30;
+  const threadPageSize = options.threadPageSize ?? 50;
+  const [state, setState] = React2.useState(() => ({
+    ...initialAgentChatState,
+    activeThreadId: options.activeThreadId ?? runtime.storage?.loadActiveThreadId?.() ?? null,
+    threads: runtime.storage?.loadThreads() ?? []
+  }));
+  const [isLoadingThreads, setIsLoadingThreads] = React2.useState(false);
+  const [isLoadingMoreThreads, setIsLoadingMoreThreads] = React2.useState(false);
+  const [threadTotal, setThreadTotal] = React2.useState();
+  const [isLoadingHistory, setIsLoadingHistory] = React2.useState(false);
+  const [isLoadingOlder, setIsLoadingOlder] = React2.useState(false);
+  const [isSubmitting, setIsSubmitting] = React2.useState(false);
+  const streamControllerRef = React2.useRef(null);
+  const attachRunRef = React2.useRef(async () => void 0);
+  const stateRef = React2.useRef(state);
+  stateRef.current = state;
+  const persist = React2.useCallback((next) => {
+    runtime.storage?.saveThreads(next.threads);
+    runtime.storage?.saveActiveThreadId?.(next.activeThreadId);
+  }, [runtime.storage]);
+  const update = React2.useCallback((updater) => {
+    setState((current) => {
+      const next = updater(current);
+      stateRef.current = next;
+      persist(next);
+      return next;
+    });
+  }, [persist]);
+  const detach = React2.useCallback(() => {
+    streamControllerRef.current?.abort();
+    streamControllerRef.current = null;
+    update((current) => ({ ...current, streamingMessageId: null, runState: current.activeRunId ? "reconnecting" : "idle" }));
+  }, [update]);
+  React2.useEffect(() => () => streamControllerRef.current?.abort(), []);
+  const refreshThreads = React2.useCallback(async () => {
+    setIsLoadingThreads(true);
+    try {
+      const result = await client.threads.list({ limit: threadPageSize });
+      setThreadTotal(result.total);
+      update((current) => {
+        const byId = new Map(current.threads.map((thread) => [thread.id, thread]));
+        const nextThreads = result.items.map((item) => {
+          const existing = byId.get(item.id);
+          return { ...existing, ...summaryToStored(item), messages: existing?.messages || [], isHydrated: existing?.isHydrated };
+        });
+        return { ...current, threads: nextThreads };
+      });
+    } finally {
+      setIsLoadingThreads(false);
+    }
+  }, [client, threadPageSize, update]);
+  const loadMoreThreads = React2.useCallback(async () => {
+    if (isLoadingMoreThreads) return;
+    const skip = stateRef.current.threads.length;
+    if (threadTotal !== void 0 && skip >= threadTotal) return;
+    setIsLoadingMoreThreads(true);
+    try {
+      const result = await client.threads.list({ skip, limit: threadPageSize });
+      setThreadTotal(result.total);
+      update((current) => {
+        const byId = new Map(current.threads.map((thread) => [thread.id, thread]));
+        for (const item of result.items) {
+          const existing = byId.get(item.id);
+          byId.set(item.id, {
+            ...existing,
+            ...summaryToStored(item),
+            messages: existing?.messages || [],
+            isHydrated: existing?.isHydrated
+          });
+        }
+        return { ...current, threads: [...byId.values()] };
+      });
+    } finally {
+      setIsLoadingMoreThreads(false);
+    }
+  }, [client, isLoadingMoreThreads, threadPageSize, threadTotal, update]);
+  const openThread = React2.useCallback(async (threadId) => {
+    detach();
+    update((current) => ({ ...current, activeThreadId: threadId, error: null, messages: current.threads.find((thread) => thread.id === threadId)?.messages || [] }));
+    setIsLoadingHistory(true);
+    try {
+      const detail = await client.threads.get({ threadId, limit: pageSize, includeRunEvents: true });
+      const messages = threadDetailToMessages(detail);
+      const stored = {
+        ...detail,
+        messages,
+        isHydrated: true,
+        hasOlderTurns: Boolean(detail.paging?.has_more),
+        nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null
+      };
+      update((current) => ({
+        ...current,
+        activeThreadId: threadId,
+        messages,
+        activeRunId: activeRunIdFromThread(stored),
+        threads: current.threads.some((thread) => thread.id === threadId) ? current.threads.map((thread) => thread.id === threadId ? stored : thread) : [stored, ...current.threads]
+      }));
+      const activeRunId = activeRunIdFromThread(stored);
+      if (activeRunId) await attachRunRef.current(activeRunId);
+    } finally {
+      setIsLoadingHistory(false);
+    }
+  }, [client, detach, pageSize, update]);
+  const consumeEvent = React2.useCallback((event) => {
+    update((current) => {
+      const next = applyRuntimeEvent(current, event);
+      if (!next.activeThreadId) return next;
+      return {
+        ...next,
+        threads: next.threads.map((thread) => thread.id === next.activeThreadId ? { ...thread, messages: next.messages, isHydrated: true, last_run_id: next.activeRunId } : thread)
+      };
+    });
+  }, [update]);
+  const attachRun = React2.useCallback(async (runId, cursor) => {
+    streamControllerRef.current?.abort();
+    const controller = runtime.createAbortController();
+    streamControllerRef.current = controller;
+    update((current) => ({ ...current, activeRunId: runId, runState: "reconnecting", error: null }));
+    try {
+      const result = await client.runs.attach({ runId, cursor, signal: controller.signal }, consumeEvent);
+      update((current) => ({ ...current, activeRunId: result.detached ? runId : current.activeRunId, cursor: result.cursor ?? current.cursor, runState: result.detached ? "reconnecting" : current.runState }));
+    } catch (error) {
+      if (!isAbortLike(error)) update((current) => ({ ...current, error, runState: "failed", streamingMessageId: null }));
+    } finally {
+      if (streamControllerRef.current === controller) streamControllerRef.current = null;
+    }
+  }, [client, consumeEvent, runtime, update]);
+  attachRunRef.current = attachRun;
+  const submit = React2.useCallback(async (input) => {
+    if (!input.text.trim() && !input.attachmentIds?.length) return;
+    detach();
+    const controller = runtime.createAbortController();
+    streamControllerRef.current = controller;
+    const userId = runtime.createId();
+    const assistantId = runtime.createId();
+    const idempotencyKey = runtime.createId();
+    const userMessage = { id: userId, role: "user", content: input.text.trim(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), parts: input.text.trim() ? [{ id: `${userId}-text`, type: "text", kind: "text", text: input.text.trim() }] : [], attachments: input.attachments };
+    const assistantMessage = { id: assistantId, role: "assistant", content: "", createdAt: (/* @__PURE__ */ new Date()).toISOString(), isFinal: false, parts: [] };
+    update((current) => ({ ...current, messages: appendStableStreamingTurn(current.messages, userMessage, assistantMessage), streamingMessageId: assistantId, runState: "streaming", error: null }));
+    setIsSubmitting(true);
+    try {
+      const result = await client.chat.stream({ input: input.text.trim(), threadId: stateRef.current.activeThreadId || void 0, attachmentIds: input.attachmentIds, requestedModelId: input.requestedModelId, idempotencyKey, signal: controller.signal }, consumeEvent);
+      update((current) => ({ ...current, activeThreadId: result.threadId || current.activeThreadId, activeRunId: result.detached ? result.runId : current.activeRunId, cursor: result.cursor, runState: result.detached ? "reconnecting" : current.runState }));
+      if (result.threadId) await refreshThreads();
+    } catch (error) {
+      if (!isAbortLike(error)) update((current) => ({ ...current, error, runState: "failed", streamingMessageId: null }));
+    } finally {
+      setIsSubmitting(false);
+      if (streamControllerRef.current === controller) streamControllerRef.current = null;
+    }
+  }, [client, consumeEvent, detach, refreshThreads, runtime, update]);
+  const startNewThread = React2.useCallback(() => {
+    detach();
+    update((current) => ({ ...initialAgentChatState, threads: current.threads }));
+  }, [detach, update]);
+  const deleteThread = React2.useCallback(async (threadId) => {
+    await client.threads.delete({ threadId, idempotencyKey: runtime.createId() });
+    update((current) => ({ ...current, activeThreadId: current.activeThreadId === threadId ? null : current.activeThreadId, messages: current.activeThreadId === threadId ? [] : current.messages, threads: current.threads.filter((thread) => thread.id !== threadId) }));
+  }, [client, runtime, update]);
+  const cancelRun = React2.useCallback(async () => {
+    const runId = stateRef.current.activeRunId;
+    if (!runId) return;
+    await client.runs.cancel({ runId, idempotencyKey: runtime.createId() });
+    detach();
+    update((current) => ({ ...current, activeRunId: null, runState: "completed", streamingMessageId: null }));
+  }, [client, detach, runtime, update]);
+  const resumeHitl = React2.useCallback(async (part, action, comment) => {
+    const runId = stateRef.current.activeRunId || stateRef.current.messages.find((message) => message.parts.includes(part))?.runId;
+    if (!runId) throw new Error("No paused run is available to resume.");
+    const result = await client.hitl.resume({ runId, interruptId: part.interruptId, action, comment, idempotencyKey: runtime.createId() });
+    await attachRun(result.run_id || runId);
+  }, [attachRun, client, runtime]);
+  const loadOlder = React2.useCallback(async () => {
+    const thread = stateRef.current.threads.find((item) => item.id === stateRef.current.activeThreadId);
+    if (!thread?.nextBeforeTurnIndex) return;
+    setIsLoadingOlder(true);
+    try {
+      const detail = await client.threads.get({ threadId: thread.id, limit: pageSize, beforeTurnIndex: thread.nextBeforeTurnIndex, includeRunEvents: true });
+      const older = threadDetailToMessages(detail);
+      update((current) => ({ ...current, messages: [...older, ...current.messages.filter((message) => !older.some((item) => item.id === message.id))], threads: current.threads.map((item) => item.id === thread.id ? { ...item, hasOlderTurns: Boolean(detail.paging?.has_more), nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null } : item) }));
+    } finally {
+      setIsLoadingOlder(false);
+    }
+  }, [client, pageSize, update]);
+  const regenerate = React2.useCallback(async (message) => {
+    const index = stateRef.current.messages.findIndex((item) => item.id === message.id);
+    const user = stateRef.current.messages.slice(0, index).reverse().find((item) => item.role === "user");
+    if (user) await submit({ text: user.content, attachments: user.attachments });
+  }, [submit]);
+  React2.useEffect(() => {
+    void refreshThreads();
+  }, [refreshThreads]);
+  React2.useEffect(() => {
+    const controller = runtime.createAbortController();
+    void client.threads.events({ signal: controller.signal }, async (event) => {
+      if (event.event === "snapshot_required") {
+        await refreshThreads();
+        return;
+      }
+      update((current) => ({ ...current, threads: applyThreadSummaryEvent(current.threads, event) }));
+    }).catch((error) => {
+      if (!isAbortLike(error)) update((current) => ({ ...current, error }));
+    });
+    return () => controller.abort();
+  }, [client, refreshThreads, runtime, update]);
+  React2.useEffect(() => {
+    const threadId = options.activeThreadId;
+    if (threadId && threadId !== stateRef.current.activeThreadId) void openThread(threadId);
+  }, [openThread, options.activeThreadId]);
+  const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId) || null;
+  const hasMoreThreads = threadTotal === void 0 ? state.threads.length >= threadPageSize : state.threads.length < threadTotal;
+  return {
+    ...state,
+    activeThread,
+    hasOlderTurns: Boolean(activeThread?.hasOlderTurns),
+    hasMoreThreads,
+    isLoadingHistory,
+    isLoadingMoreThreads,
+    isLoadingOlder,
+    isLoadingThreads,
+    isSubmitting,
+    attachRun,
+    cancelRun,
+    deleteThread,
+    detach,
+    loadOlder,
+    loadMoreThreads,
+    openThread,
+    refreshThreads,
+    regenerate,
+    resumeHitl,
+    startNewThread,
+    submit
+  };
+}
+
+// src/use-agent-resources.ts
+import * as React3 from "react";
+function useAgentThreads(options = {}) {
+  const { client, createAbortController } = useAgents24Runtime();
+  const [threads, setThreads] = React3.useState([]);
+  const [total, setTotal] = React3.useState();
+  const [isLoading, setIsLoading] = React3.useState(true);
+  const [error, setError] = React3.useState(null);
+  const controllerRef = React3.useRef(null);
+  const load = React3.useCallback(async () => {
+    controllerRef.current?.abort();
+    const controller = createAbortController();
+    controllerRef.current = controller;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await client.threads.list({ ...options, signal: controller.signal });
+      setThreads(result.items);
+      setTotal(result.total);
+    } catch (nextError) {
+      if (!isAbortLike(nextError)) setError(nextError);
+    } finally {
+      if (controllerRef.current === controller) {
+        controllerRef.current = null;
+        setIsLoading(false);
+      }
+    }
+  }, [client, createAbortController, options.limit, options.skip]);
+  React3.useEffect(() => {
+    void load();
+    return () => controllerRef.current?.abort();
+  }, [load]);
+  return { error, isLoading, refresh: load, threads, total };
+}
+function useAgentThread(threadId, options = {}) {
+  const { client, createAbortController } = useAgents24Runtime();
+  const [thread, setThread] = React3.useState(null);
+  const [isLoading, setIsLoading] = React3.useState(Boolean(threadId));
+  const [error, setError] = React3.useState(null);
+  const controllerRef = React3.useRef(null);
+  const load = React3.useCallback(async () => {
+    if (!threadId) {
+      controllerRef.current?.abort();
+      controllerRef.current = null;
+      setThread(null);
+      setIsLoading(false);
+      return null;
+    }
+    controllerRef.current?.abort();
+    const controller = createAbortController();
+    controllerRef.current = controller;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await client.threads.get({ threadId, ...options, signal: controller.signal });
+      setThread(result);
+      return result;
+    } catch (nextError) {
+      if (!isAbortLike(nextError)) setError(nextError);
+      return null;
+    } finally {
+      if (controllerRef.current === controller) {
+        controllerRef.current = null;
+        setIsLoading(false);
+      }
+    }
+  }, [client, createAbortController, options.beforeTurnIndex, options.includeRunEvents, options.limit, threadId]);
+  React3.useEffect(() => {
+    void load();
+    return () => controllerRef.current?.abort();
+  }, [load]);
+  return { error, isLoading, refresh: load, thread };
+}
+function useAgentRun() {
+  const { client, createAbortController, createId } = useAgents24Runtime();
+  const controllerRef = React3.useRef(null);
+  const [isAttached, setIsAttached] = React3.useState(false);
+  const [error, setError] = React3.useState(null);
+  React3.useEffect(() => () => controllerRef.current?.abort(), []);
+  const detach = React3.useCallback(() => {
+    controllerRef.current?.abort();
+    controllerRef.current = null;
+    setIsAttached(false);
+  }, []);
+  const attach = React3.useCallback(async (runId, onEvent, cursor) => {
+    detach();
+    const controller = createAbortController();
+    controllerRef.current = controller;
+    setError(null);
+    setIsAttached(true);
+    try {
+      return await client.runs.attach({ runId, cursor, signal: controller.signal }, onEvent);
+    } catch (nextError) {
+      if (!isAbortLike(nextError)) setError(nextError);
+      throw nextError;
+    } finally {
+      if (controllerRef.current === controller) controllerRef.current = null;
+      setIsAttached(false);
+    }
+  }, [client, createAbortController, detach]);
+  const cancel = React3.useCallback(async (runId) => {
+    const result = await client.runs.cancel({ runId, idempotencyKey: createId() });
+    detach();
+    return result;
+  }, [client, createId, detach]);
+  return { attach, cancel, detach, error, isAttached };
+}
+function useAgentAttachments() {
+  const { client, createId } = useAgents24Runtime();
+  const [uploads, setUploads] = React3.useState({});
+  const [isUploading, setIsUploading] = React3.useState(false);
+  const upload = React3.useCallback(async (input) => {
+    setIsUploading(true);
+    try {
+      const result = await client.attachments.upload({ upload: input, threadId: input.threadId, idempotencyKey: createId(), signal: input.signal });
+      setUploads((current) => ({ ...current, [result.id]: result }));
+      return attachmentResultToChatAttachment(result);
+    } finally {
+      setIsUploading(false);
+    }
+  }, [client, createId]);
+  return { isUploading, upload, uploads };
+}
+function useAgentHitl() {
+  const { client, createId } = useAgents24Runtime();
+  const [isResolving, setIsResolving] = React3.useState(false);
+  const [lastResult, setLastResult] = React3.useState(null);
+  const resume = React3.useCallback(async (input) => {
+    setIsResolving(true);
+    try {
+      const result = await client.hitl.resume({ ...input, idempotencyKey: createId() });
+      setLastResult(result);
+      return result;
+    } finally {
+      setIsResolving(false);
+    }
+  }, [client, createId]);
+  return { isResolving, lastResult, resume };
+}
+function useAgentMcp() {
+  const { client, createId } = useAgents24Runtime();
+  const [isAuthorizing, setIsAuthorizing] = React3.useState(false);
+  const startAuthorization = React3.useCallback(async (input) => {
+    setIsAuthorizing(true);
+    try {
+      return await client.mcp.startAuthorization({ ...input, idempotencyKey: createId() });
+    } finally {
+      setIsAuthorizing(false);
+    }
+  }, [client, createId]);
+  const redeemCallback = React3.useCallback(async (input) => client.mcp.redeemCallback({ ...input, idempotencyKey: createId() }), [client, createId]);
+  return { isAuthorizing, redeemCallback, startAuthorization };
+}
+export {
+  Agents24Provider,
+  appendStableStreamingTurn,
+  applyRuntimeEvent,
+  applyThreadSummaryEvent,
+  assistantProjectionFromEvent,
+  attachmentResultToChatAttachment,
+  createPortableId,
+  initialAgentChatState,
+  isAbortLike,
+  partsFromResponseBlocks,
+  threadDetailToMessages,
+  upsertStableAssistantMessage,
+  useAgentAttachments,
+  useAgentChat,
+  useAgentClient,
+  useAgentHitl,
+  useAgentMcp,
+  useAgentRun,
+  useAgentThread,
+  useAgentThreads,
+  useAgents24Runtime
+};
+//# sourceMappingURL=index.js.map