@lumerahq/ui 0.7.6 → 0.8.0-dev.0

package/dist/use-automation-run-rhYZZhj7.js

@@ -0,0 +1,746 @@
+import { useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { useQueryClient, useMutation, useQuery } from "@tanstack/react-query";
+import { m as ensureAutomationRun, k as createAutomationRun, f as cancelAutomationRun, e as automationStatuses, r as getAutomationRun } from "./automations-BEBG7FqJ.js";
+const DEFAULT_SESSION_ID = "default";
+const DEFAULT_HISTORY_LIMIT = 10;
+const DEFAULT_MAX_BUFFERED_MESSAGES = 100;
+const DEFAULT_MAX_QUEUED_MESSAGES = 1;
+function useAgentChat({
+  agentId,
+  sessionId = DEFAULT_SESSION_ID,
+  transport,
+  initialMessages = [],
+  initialPage,
+  historyLimit = DEFAULT_HISTORY_LIMIT,
+  maxBufferedMessages = DEFAULT_MAX_BUFFERED_MESSAGES,
+  maxQueuedMessages = DEFAULT_MAX_QUEUED_MESSAGES,
+  disabled = false,
+  autoLoadHistory = true,
+  autoSubscribe = true,
+  idFactory = defaultIDFactory,
+  onMessagesChange,
+  onTurnComplete,
+  onError
+}) {
+  const [messages, setMessagesState] = useState(
+    () => trimMessages(initialMessages, maxBufferedMessages)
+  );
+  const [input, setInput] = useState("");
+  const [pendingFiles, setPendingFiles] = useState([]);
+  const [page, setPage] = useState(initialPage ?? null);
+  const [tokenUsage, setTokenUsage] = useState(null);
+  const [error, setError] = useState(null);
+  const [isLoadingHistory, setIsLoadingHistory] = useState(false);
+  const [isLoadingEarlier, setIsLoadingEarlier] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [isAborting, setIsAborting] = useState(false);
+  const messagesRef = useRef(messages);
+  const subscriptionRef = useRef(null);
+  const activeRequestIdRef = useRef(void 0);
+  const mountedRef = useRef(true);
+  const setMessages = useCallback(
+    (updater) => {
+      setMessagesState((current) => {
+        const nextRaw = typeof updater === "function" ? updater(current) : updater;
+        const next = trimMessages(nextRaw, maxBufferedMessages);
+        messagesRef.current = next;
+        onMessagesChange?.(next);
+        return next;
+      });
+    },
+    [maxBufferedMessages, onMessagesChange]
+  );
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      subscriptionRef.current?.close();
+      subscriptionRef.current = null;
+    };
+  }, []);
+  const handleError = useCallback(
+    (err) => {
+      if (!mountedRef.current) return;
+      setError(err);
+      onError?.(err);
+    },
+    [onError]
+  );
+  const applyHistoryResult = useCallback(
+    (result) => {
+      const projected = mergePendingMessages(result.messages, result.pending ?? []);
+      setMessages((current) => mergeUniqueMessages([...projected, ...missingActiveUserMessages(current, projected)]));
+      setPage(result.page ?? null);
+    },
+    [setMessages]
+  );
+  const loadHistory = useCallback(async () => {
+    if (disabled) return;
+    setIsLoadingHistory(true);
+    setError(null);
+    try {
+      const result = await transport.loadHistory({ agentId, sessionId, limit: historyLimit });
+      if (!mountedRef.current) return;
+      applyHistoryResult(result);
+    } catch (err) {
+      handleError(err);
+    } finally {
+      if (mountedRef.current) setIsLoadingHistory(false);
+    }
+  }, [agentId, applyHistoryResult, disabled, handleError, historyLimit, sessionId, transport]);
+  const loadEarlier = useCallback(async () => {
+    if (disabled || isLoadingEarlier || !page?.hasMoreBefore || !page.beforeCursor) return;
+    const loadEarlierImpl = transport.loadEarlier ?? transport.loadHistory;
+    setIsLoadingEarlier(true);
+    setError(null);
+    try {
+      const result = await loadEarlierImpl({
+        agentId,
+        sessionId,
+        beforeCursor: page.beforeCursor,
+        limit: historyLimit
+      });
+      if (!mountedRef.current) return;
+      const earlier = mergePendingMessages(result.messages, result.pending ?? []);
+      setMessages((current) => mergeUniqueMessages([...earlier, ...current]));
+      setPage(result.page ?? page);
+    } catch (err) {
+      handleError(err);
+    } finally {
+      if (mountedRef.current) setIsLoadingEarlier(false);
+    }
+  }, [agentId, disabled, handleError, historyLimit, isLoadingEarlier, page, sessionId, setMessages, transport]);
+  const settleRequest = useCallback(
+    (requestId, status, errorMessage) => {
+      if (!requestId) return;
+      setMessages(
+        (current) => current.map(
+          (messageItem) => messageItem.role === "user" && messageItem.requestId === requestId ? { ...messageItem, status, error: errorMessage ?? messageItem.error } : messageItem
+        )
+      );
+      setIsStreaming(false);
+      const turn = buildAgentChatTurns(messagesRef.current).find((item) => item.requestId === requestId);
+      if (turn) onTurnComplete?.(turn);
+      if (!transport.subscribe) return;
+      void loadHistory();
+    },
+    [loadHistory, onTurnComplete, setMessages, transport.subscribe]
+  );
+  const applyStreamEvent = useCallback(
+    (event) => {
+      setError(null);
+      switch (event.type) {
+        case "text_delta":
+          setMessages((current) => applyAssistantDelta(current, event.requestId, "text", event.delta));
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "thinking_delta":
+          setMessages((current) => applyAssistantDelta(current, event.requestId, "thinking", event.delta));
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "message":
+          setMessages((current) => mergeUniqueMessages([...current, event.message]));
+          if (event.message.requestId) markUserTurnRunning(setMessages, event.message.requestId);
+          return;
+        case "tool_start":
+        case "tool_update":
+        case "tool_end":
+          setMessages((current) => upsertAssistantToolBlock(current, event.requestId, event.toolCall));
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "action":
+          setMessages(
+            (current) => appendAssistantBlock(current, event.requestId, { type: "action", action: event.action })
+          );
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "file":
+          setMessages((current) => appendAssistantBlock(current, event.requestId, { type: "file", file: event.file }));
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "info":
+          setMessages(
+            (current) => appendAssistantBlock(current, event.requestId, {
+              type: "info",
+              content: event.content,
+              tone: event.tone
+            })
+          );
+          markUserTurnRunning(setMessages, event.requestId);
+          return;
+        case "usage":
+          setTokenUsage((current) => accumulateTokenUsage(current, event.usage));
+          return;
+        case "terminal":
+          settleRequest(event.requestId, event.status ?? "completed", event.error);
+          return;
+        case "error":
+          settleRequest(event.requestId, "failed", event.error);
+          handleError(new Error(event.error));
+          return;
+        case "custom":
+          return;
+      }
+    },
+    [handleError, setMessages, settleRequest]
+  );
+  const startSubscription = useCallback(
+    (requestId) => {
+      if (!autoSubscribe || !transport.subscribe || !requestId) return;
+      subscriptionRef.current?.close();
+      activeRequestIdRef.current = requestId;
+      setIsStreaming(true);
+      subscriptionRef.current = transport.subscribe(
+        { agentId, sessionId, requestId },
+        {
+          onEvent: applyStreamEvent,
+          onError: (err) => {
+            handleError(err);
+            if (mountedRef.current) setIsStreaming(false);
+          },
+          onClose: () => {
+            if (mountedRef.current && activeRequestIdRef.current === requestId) {
+              setIsStreaming(false);
+            }
+          }
+        }
+      );
+    },
+    [agentId, applyStreamEvent, autoSubscribe, handleError, sessionId, transport]
+  );
+  const sendMessage = useCallback(
+    async (message) => {
+      const content = (message ?? input).trim();
+      if (disabled || isSubmitting || !content && pendingFiles.length === 0) {
+        return { accepted: false, error: "Nothing to send" };
+      }
+      const active = activeUserMessages(messagesRef.current);
+      const queued = active.filter((item) => item.status === "queued").length;
+      if (active.length > 0 && queued >= maxQueuedMessages) {
+        return { accepted: false, error: "Queue is full" };
+      }
+      const requestId = idFactory();
+      setIsSubmitting(true);
+      setError(null);
+      try {
+        const result = await transport.sendMessage({
+          message: content,
+          requestId,
+          sessionId,
+          files: pendingFiles
+        });
+        if (!mountedRef.current) return result;
+        if (result.accepted) {
+          setInput("");
+          setPendingFiles([]);
+          if (result.pending) {
+            setMessages((current) => mergeUniqueMessages([...current, result.pending]));
+          } else if (!transport.subscribe) {
+            await loadHistory();
+          }
+          startSubscription(result.requestId ?? requestId);
+        }
+        return result;
+      } catch (err) {
+        handleError(err);
+        return { accepted: false, requestId, error: err instanceof Error ? err.message : String(err) };
+      } finally {
+        if (mountedRef.current) setIsSubmitting(false);
+      }
+    },
+    [
+      disabled,
+      handleError,
+      idFactory,
+      input,
+      isSubmitting,
+      loadHistory,
+      maxQueuedMessages,
+      pendingFiles,
+      sessionId,
+      setMessages,
+      startSubscription,
+      transport
+    ]
+  );
+  const abort = useCallback(async () => {
+    if (disabled || isAborting) return;
+    const requestId = latestActiveRequestId(messagesRef.current);
+    setIsAborting(true);
+    try {
+      await transport.abort?.({ agentId, sessionId, requestId });
+      subscriptionRef.current?.close();
+      subscriptionRef.current = null;
+      setIsStreaming(false);
+      setMessages(
+        (current) => current.map(
+          (messageItem) => messageItem.role === "user" && isActiveStatus(messageItem.status) ? { ...messageItem, status: "interrupted" } : messageItem
+        )
+      );
+    } catch (err) {
+      handleError(err);
+    } finally {
+      if (mountedRef.current) setIsAborting(false);
+    }
+  }, [agentId, disabled, handleError, isAborting, sessionId, setMessages, transport]);
+  const attachFiles = useCallback(
+    async (files) => {
+      if (files.length === 0) return;
+      const pending = files.map((file) => ({
+        id: idFactory(),
+        file,
+        name: file.name,
+        mimeType: file.type,
+        size: file.size,
+        status: transport.uploadFile ? "uploading" : "pending"
+      }));
+      setPendingFiles((current) => [...current, ...pending]);
+      if (!transport.uploadFile) return;
+      await Promise.all(
+        pending.map(async (pendingFile) => {
+          if (!pendingFile.file) return;
+          try {
+            const upload = await transport.uploadFile?.(pendingFile.file);
+            if (!mountedRef.current) return;
+            setPendingFiles(
+              (current) => current.map((item) => item.id === pendingFile.id ? { ...item, upload, status: "uploaded" } : item)
+            );
+          } catch (err) {
+            if (!mountedRef.current) return;
+            const messageText = err instanceof Error ? err.message : String(err);
+            setPendingFiles(
+              (current) => current.map(
+                (item) => item.id === pendingFile.id ? { ...item, status: "failed", error: messageText } : item
+              )
+            );
+            handleError(err);
+          }
+        })
+      );
+    },
+    [handleError, idFactory, transport]
+  );
+  const removePendingFile = useCallback((id) => {
+    setPendingFiles((current) => current.filter((file) => file.id !== id));
+  }, []);
+  const clearPendingFiles = useCallback(() => {
+    setPendingFiles([]);
+  }, []);
+  useEffect(() => {
+    if (!autoLoadHistory) return;
+    void loadHistory();
+  }, [autoLoadHistory, loadHistory]);
+  const turns = useMemo(() => buildAgentChatTurns(messages), [messages]);
+  const queueLength = useMemo(
+    () => messages.filter((message) => message.role === "user" && message.status === "queued").length,
+    [messages]
+  );
+  const hasActive = useMemo(() => activeUserMessages(messages).length > 0, [messages]);
+  const hasFailedUploads = pendingFiles.some((file) => file.status === "failed");
+  const hasUploadingFiles = pendingFiles.some((file) => file.status === "uploading");
+  const canSubmit = !disabled && !isSubmitting && !hasUploadingFiles && !hasFailedUploads && (input.trim().length > 0 || pendingFiles.length > 0) && (!hasActive || queueLength < maxQueuedMessages);
+  const canAbort = !disabled && !isAborting && hasActive;
+  const phase = derivePhase({ isLoadingHistory, isLoadingEarlier, isSubmitting, isStreaming, isAborting, error });
+  return {
+    messages,
+    turns,
+    input,
+    setInput,
+    pendingFiles,
+    attachFiles,
+    removePendingFile,
+    clearPendingFiles,
+    phase,
+    error,
+    page,
+    tokenUsage,
+    isLoadingHistory,
+    isLoadingEarlier,
+    isSubmitting,
+    isStreaming,
+    isAborting,
+    canLoadEarlier: Boolean(page?.hasMoreBefore && page.beforeCursor),
+    queueLength,
+    canSubmit,
+    canAbort,
+    loadHistory,
+    loadEarlier,
+    sendMessage,
+    abort
+  };
+}
+function derivePhase(input) {
+  if (input.isLoadingHistory) return "loading-history";
+  if (input.isLoadingEarlier) return "loading-earlier";
+  if (input.isSubmitting) return "submitting";
+  if (input.isAborting) return "aborting";
+  if (input.isStreaming) return "streaming";
+  if (input.error) return "error";
+  return "idle";
+}
+function defaultIDFactory() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `chat_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function isActiveStatus(status) {
+  return status === "queued" || status === "claimed" || status === "preparing" || status === "submitting" || status === "running";
+}
+function activeUserMessages(messages) {
+  return messages.filter((message) => message.role === "user" && isActiveStatus(message.status));
+}
+function latestActiveRequestId(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "user" && isActiveStatus(message.status) && message.requestId) {
+      return message.requestId;
+    }
+  }
+  return void 0;
+}
+function messageKeys(message) {
+  const keys = [`${message.role}:id:${message.id}`];
+  if (message.role === "user" && message.requestId) {
+    keys.push(`user:request:${message.requestId}`);
+  }
+  return keys;
+}
+function mergeUniqueMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const message of messages) {
+    const keys = messageKeys(message);
+    if (keys.some((key) => seen.has(key))) continue;
+    keys.forEach((key) => seen.add(key));
+    merged.push(message);
+  }
+  return merged;
+}
+function trimMessages(messages, max) {
+  return max > 0 && messages.length > max ? messages.slice(-max) : messages;
+}
+function mergePendingMessages(messages, pending) {
+  const next = [...messages];
+  for (const pendingMessage of pending) {
+    if (!pendingMessage.requestId) {
+      insertChronologically(next, pendingMessage);
+      continue;
+    }
+    const matchIndex = next.findIndex(
+      (message) => message.role === "user" && message.requestId === pendingMessage.requestId
+    );
+    if (matchIndex >= 0) {
+      const matched = next[matchIndex];
+      next[matchIndex] = {
+        ...matched,
+        content: matched?.content || pendingMessage.content,
+        timestamp: matched?.timestamp || pendingMessage.timestamp,
+        status: matched?.status && !isActiveStatus(matched.status) ? matched.status : pendingMessage.status,
+        error: matched?.error ?? pendingMessage.error,
+        errorCategory: matched?.errorCategory ?? pendingMessage.errorCategory
+      };
+      continue;
+    }
+    insertChronologically(next, pendingMessage);
+  }
+  return next;
+}
+function missingActiveUserMessages(current, projected) {
+  const projectedRequestIds = new Set(projected.map((message) => message.requestId).filter(Boolean));
+  return current.filter(
+    (message) => message.role === "user" && isActiveStatus(message.status) && message.requestId && !projectedRequestIds.has(message.requestId)
+  );
+}
+function timestampMs(timestamp) {
+  if (!timestamp) return null;
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function insertChronologically(messages, message) {
+  const ts = timestampMs(message.timestamp);
+  if (ts == null) {
+    messages.push(message);
+    return;
+  }
+  let insertAt = messages.length;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const currentTs = timestampMs(messages[index]?.timestamp);
+    if (currentTs == null) continue;
+    if (currentTs <= ts) {
+      insertAt = index + 1;
+      break;
+    }
+    insertAt = index;
+  }
+  messages.splice(insertAt, 0, message);
+}
+function upsertAssistantToolBlock(messages, requestId, toolCall) {
+  const block = { type: "tool_call", toolCall };
+  const next = [...messages];
+  const index = latestAssistantIndex(next, requestId);
+  if (index < 0) {
+    return appendAssistantBlock(messages, requestId, block);
+  }
+  const message = next[index];
+  const blocks = [...message?.blocks ?? []];
+  const blockIndex = blocks.findIndex((item) => item.type === "tool_call" && item.toolCall.id === toolCall.id);
+  if (blockIndex >= 0) {
+    blocks[blockIndex] = block;
+  } else {
+    blocks.push(block);
+  }
+  next[index] = {
+    ...message,
+    blocks,
+    toolCalls: blocks.flatMap((item) => item.type === "tool_call" ? [item.toolCall] : [])
+  };
+  return next;
+}
+function appendAssistantBlock(messages, requestId, block) {
+  const next = [...messages];
+  const index = latestAssistantIndex(next, requestId);
+  if (index >= 0) {
+    const message = next[index];
+    next[index] = {
+      ...message,
+      blocks: [...message?.blocks ?? [], block]
+    };
+    return next;
+  }
+  next.push({
+    id: `assistant:${requestId ?? defaultIDFactory()}`,
+    role: "assistant",
+    content: "",
+    requestId,
+    blocks: [block]
+  });
+  return next;
+}
+function applyAssistantDelta(messages, requestId, blockType, delta) {
+  if (!delta) return messages;
+  const next = [...messages];
+  const index = latestAssistantIndex(next, requestId);
+  if (index < 0) {
+    const block = blockType === "text" ? { type: "text", content: delta } : { type: "thinking", content: delta };
+    next.push({
+      id: `assistant:${requestId ?? defaultIDFactory()}`,
+      role: "assistant",
+      content: blockType === "text" ? delta : "",
+      requestId,
+      blocks: [block]
+    });
+    return next;
+  }
+  const message = next[index];
+  const blocks = [...message?.blocks ?? []];
+  const last = blocks[blocks.length - 1];
+  if (last?.type === blockType) {
+    blocks[blocks.length - 1] = { ...last, content: last.content + delta };
+  } else {
+    blocks.push(blockType === "text" ? { type: "text", content: delta } : { type: "thinking", content: delta });
+  }
+  next[index] = {
+    ...message,
+    content: blockType === "text" ? `${message?.content ?? ""}${delta}` : message?.content ?? "",
+    blocks
+  };
+  return next;
+}
+function latestAssistantIndex(messages, requestId) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant") continue;
+    if (!requestId || message.requestId === requestId) return index;
+  }
+  return -1;
+}
+function markUserTurnRunning(setMessages, requestId) {
+  if (!requestId) return;
+  setMessages(
+    (current) => current.map(
+      (message) => message.role === "user" && message.requestId === requestId && isActiveStatus(message.status) && message.status !== "running" ? { ...message, status: "running" } : message
+    )
+  );
+}
+function buildAgentChatTurns(messages) {
+  const turns = [];
+  const turnByRequest = /* @__PURE__ */ new Map();
+  let latestUserTurn;
+  for (const message of messages) {
+    if (message.role === "system") {
+      turns.push({ id: message.id, systems: [message], assistants: [] });
+      continue;
+    }
+    if (message.role === "user") {
+      const turn2 = {
+        id: message.requestId ?? message.id,
+        requestId: message.requestId,
+        user: message,
+        assistants: [],
+        status: message.status
+      };
+      turns.push(turn2);
+      latestUserTurn = turn2;
+      if (message.requestId) turnByRequest.set(message.requestId, turn2);
+      continue;
+    }
+    const turn = message.requestId ? turnByRequest.get(message.requestId) : latestUserTurn;
+    if (turn) {
+      turn.assistants.push(message);
+    } else {
+      turns.push({ id: message.requestId ?? message.id, requestId: message.requestId, assistants: [message] });
+    }
+  }
+  return turns;
+}
+function accumulateTokenUsage(current, incoming) {
+  if (!current) return incoming;
+  return {
+    input: current.input + incoming.input,
+    output: current.output + incoming.output,
+    cacheRead: (current.cacheRead ?? 0) + (incoming.cacheRead ?? 0),
+    cacheWrite: (current.cacheWrite ?? 0) + (incoming.cacheWrite ?? 0),
+    total: (current.total ?? 0) + (incoming.total ?? 0),
+    cost: incoming.cost ? {
+      input: (current.cost?.input ?? 0) + (incoming.cost.input ?? 0),
+      output: (current.cost?.output ?? 0) + (incoming.cost.output ?? 0),
+      cacheRead: (current.cost?.cacheRead ?? 0) + (incoming.cost.cacheRead ?? 0),
+      cacheWrite: (current.cost?.cacheWrite ?? 0) + (incoming.cost.cacheWrite ?? 0),
+      total: (current.cost?.total ?? 0) + (incoming.cost.total ?? 0)
+    } : current.cost
+  };
+}
+function useAutomationRun(options) {
+  const {
+    agentId,
+    inputs,
+    externalId,
+    autoStart = true,
+    pollIntervalMs = 2e3,
+    dedupeWithExternalId = true,
+    onComplete,
+    onCreated,
+    onUpdate
+  } = options;
+  const queryClient = useQueryClient();
+  const [currentRunId, setCurrentRunId] = useState(null);
+  const [errorV, setErrorV] = useState(null);
+  const startMutation = useMutation({
+    mutationFn: async () => {
+      setErrorV(null);
+      if (!agentId) throw new Error("agentId is required");
+      if (externalId && dedupeWithExternalId) {
+        return ensureAutomationRun({ agentId, inputs, externalId });
+      }
+      return createAutomationRun({ agentId, inputs, externalId });
+    },
+    onSuccess: (data) => {
+      setCurrentRunId(data.id);
+      queryClient.setQueryData(["automation-run", data.id], data);
+      onCreated?.(data);
+      onUpdate?.(data);
+    },
+    onError: (err) => {
+      setErrorV(err instanceof Error ? err.message : "Unable to start automation");
+    }
+  });
+  const cancelMutation = useMutation({
+    mutationFn: async (runId) => {
+      return cancelAutomationRun(runId);
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(["automation-run", data.id], data);
+      onUpdate?.(data);
+    },
+    onError: (err) => {
+      setErrorV(err instanceof Error ? err.message : "Unable to cancel automation");
+    }
+  });
+  const {
+    data: run,
+    isError: isQueryError,
+    error: queryError,
+    refetch
+  } = useQuery({
+    queryKey: ["automation-run", currentRunId],
+    queryFn: async () => {
+      if (!currentRunId) return null;
+      return getAutomationRun(currentRunId);
+    },
+    enabled: !!currentRunId,
+    // Poll while active, stop when terminal
+    refetchInterval: (query) => {
+      const status = query.state.data?.status;
+      if (status && automationStatuses.TERMINAL_STATUSES.includes(status)) {
+        return false;
+      }
+      return pollIntervalMs;
+    },
+    // Immediately show data from setQueryData
+    initialData: void 0
+  });
+  const completedRunRef = useRef(null);
+  useEffect(() => {
+    if (run) {
+      onUpdate?.(run);
+      if (automationStatuses.TERMINAL_STATUSES.includes(run.status)) {
+        if (completedRunRef.current !== run.id) {
+          completedRunRef.current = run.id;
+          onComplete?.(run);
+        }
+      } else {
+        if (completedRunRef.current === run.id) {
+          completedRunRef.current = null;
+        }
+      }
+    }
+  }, [run, onComplete, onUpdate]);
+  useEffect(() => {
+    if (isQueryError && queryError) {
+      setErrorV(queryError instanceof Error ? queryError.message : "Failed to poll automation");
+    }
+  }, [isQueryError, queryError]);
+  const start = useCallback(async () => {
+    try {
+      const result = await startMutation.mutateAsync();
+      return result;
+    } catch {
+      return null;
+    }
+  }, [startMutation]);
+  const cancel = useCallback(async () => {
+    if (!currentRunId) return null;
+    try {
+      return await cancelMutation.mutateAsync(currentRunId);
+    } catch {
+      return null;
+    }
+  }, [cancelMutation, currentRunId]);
+  const refresh = useCallback(async () => {
+    if (!currentRunId) return start();
+    const result = await refetch();
+    return result.data ?? null;
+  }, [currentRunId, refetch, start]);
+  const autoStartedRef = useRef(false);
+  useEffect(() => {
+    if (autoStart && !autoStartedRef.current && !currentRunId) {
+      autoStartedRef.current = true;
+      void start();
+    }
+  }, [autoStart, currentRunId, start]);
+  return {
+    run: run ?? null,
+    status: run?.status ?? "idle",
+    isLoading: startMutation.isPending || cancelMutation.isPending,
+    error: errorV,
+    start,
+    refresh,
+    cancel
+  };
+}
+export {
+  useAutomationRun as a,
+  useAgentChat as u
+};