@lov3kaizen/agentsea-react 0.4.0 → 0.5.2

package/dist/index.mjs

@@ -220,9 +220,807 @@ var useStreamingContent = () => {
     consumeStream
   };
 };
+
+// src/useChat.ts
+import { useState, useCallback, useRef, useEffect } from "react";
+
+// src/types.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function createMessage(role, content, options) {
+  return {
+    id: generateId(),
+    role,
+    content,
+    createdAt: /* @__PURE__ */ new Date(),
+    ...options
+  };
+}
+
+// src/adapters.ts
+function createSSEAdapter() {
+  let eventSource = null;
+  let abortController = null;
+  let messageCallback = null;
+  let errorCallback = null;
+  let closeCallback = null;
+  let currentUrl = "";
+  let currentOptions = {};
+  return {
+    connect(url, options) {
+      currentUrl = url;
+      currentOptions = options || {};
+      abortController = new AbortController();
+      if (options?.signal) {
+        options.signal.addEventListener("abort", () => {
+          abortController?.abort();
+        });
+      }
+      return Promise.resolve();
+    },
+    async send(data) {
+      const response = await fetch(currentUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...currentOptions.headers
+        },
+        body: JSON.stringify(data),
+        signal: abortController?.signal
+      });
+      if (!response.ok) {
+        const error = new Error(`HTTP error: ${response.status}`);
+        errorCallback?.(error);
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        errorCallback?.(new Error("No response body"));
+        return;
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        let reading = true;
+        while (reading) {
+          const { done, value } = await reader.read();
+          if (done) {
+            reading = false;
+            continue;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const eventData = line.slice(6);
+              if (eventData === "[DONE]") {
+                closeCallback?.();
+                return;
+              }
+              try {
+                const chunk = JSON.parse(eventData);
+                messageCallback?.(chunk);
+              } catch {
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (error.name !== "AbortError") {
+          errorCallback?.(error);
+        }
+      } finally {
+        closeCallback?.();
+      }
+    },
+    onMessage(callback) {
+      messageCallback = callback;
+    },
+    onError(callback) {
+      errorCallback = callback;
+    },
+    onClose(callback) {
+      closeCallback = callback;
+    },
+    close() {
+      abortController?.abort();
+      eventSource?.close();
+      eventSource = null;
+    }
+  };
+}
+function createHTTPStreamAdapter() {
+  let abortController = null;
+  let messageCallback = null;
+  let errorCallback = null;
+  let closeCallback = null;
+  let currentUrl = "";
+  let currentOptions = {};
+  return {
+    connect(url, options) {
+      currentUrl = url;
+      currentOptions = options || {};
+      abortController = new AbortController();
+      if (options?.signal) {
+        options.signal.addEventListener("abort", () => {
+          abortController?.abort();
+        });
+      }
+      return Promise.resolve();
+    },
+    async send(data) {
+      try {
+        const response = await fetch(currentUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/x-ndjson",
+            ...currentOptions.headers
+          },
+          body: JSON.stringify(data),
+          signal: abortController?.signal
+        });
+        if (!response.ok) {
+          const error = new Error(`HTTP error: ${response.status}`);
+          errorCallback?.(error);
+          return;
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+          errorCallback?.(new Error("No response body"));
+          return;
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let reading = true;
+        while (reading) {
+          const { done, value } = await reader.read();
+          if (done) {
+            reading = false;
+            continue;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const chunk = JSON.parse(line);
+                messageCallback?.(chunk);
+              } catch {
+              }
+            }
+          }
+        }
+        if (buffer.trim()) {
+          try {
+            const chunk = JSON.parse(buffer);
+            messageCallback?.(chunk);
+          } catch {
+          }
+        }
+      } catch (error) {
+        if (error.name !== "AbortError") {
+          errorCallback?.(error);
+        }
+      } finally {
+        closeCallback?.();
+      }
+    },
+    onMessage(callback) {
+      messageCallback = callback;
+    },
+    onError(callback) {
+      errorCallback = callback;
+    },
+    onClose(callback) {
+      closeCallback = callback;
+    },
+    close() {
+      abortController?.abort();
+    }
+  };
+}
+async function fetchChat(url, data, options) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    },
+    body: JSON.stringify({ ...data, stream: false }),
+    signal: options?.signal
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP error: ${response.status}`);
+  }
+  const result = await response.json();
+  return result.chunks || [result];
+}
+function getAdapter(type) {
+  if (typeof type === "object") {
+    return type;
+  }
+  return type === "sse" ? createSSEAdapter() : createHTTPStreamAdapter();
+}
+
+// src/useChat.ts
+function useChat(config) {
+  const {
+    endpoint,
+    conversationId: initialConversationId,
+    agentId,
+    initialMessages = [],
+    adapter: adapterType = "sse",
+    headers = {},
+    onMessage,
+    onContentUpdate,
+    onToolApproval,
+    onError,
+    onComplete,
+    onThinking,
+    autoApprove = false,
+    maxRetries = 3
+  } = config;
+  const [messages, setMessages] = useState(initialMessages);
+  const [streamingContent, setStreamingContent] = useState("");
+  const [thinkingContent, setThinkingContent] = useState("");
+  const [activeToolCalls, setActiveToolCalls] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [error, setError] = useState(null);
+  const adapterRef = useRef(getAdapter(adapterType));
+  const abortControllerRef = useRef(null);
+  const conversationIdRef = useRef(initialConversationId || generateId());
+  const pendingApprovalsRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const retryCountRef = useRef(0);
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+      adapterRef.current.close();
+    };
+  }, []);
+  const processChunk = useCallback(
+    (chunk) => {
+      switch (chunk.type) {
+        case "content":
+          if (chunk.delta) {
+            setStreamingContent((prev) => prev + chunk.content);
+          } else {
+            setStreamingContent(chunk.content);
+          }
+          onContentUpdate?.(chunk.content);
+          break;
+        case "thinking": {
+          if (chunk.delta) {
+            setThinkingContent((prev) => prev + chunk.content);
+          } else {
+            setThinkingContent(chunk.content);
+          }
+          const thinking = {
+            type: "thinking",
+            content: chunk.content,
+            isComplete: false
+          };
+          onThinking?.(thinking);
+          break;
+        }
+        case "tool_call":
+          setActiveToolCalls((prev) => {
+            const existing = prev.find((tc) => tc.id === chunk.toolCall.id);
+            if (existing) {
+              return prev.map(
+                (tc) => tc.id === chunk.toolCall.id ? chunk.toolCall : tc
+              );
+            }
+            return [...prev, chunk.toolCall];
+          });
+          if (chunk.toolCall.needsApproval && !autoApprove) {
+            onToolApproval?.(chunk.toolCall);
+          } else if (autoApprove && chunk.toolCall.needsApproval) {
+            pendingApprovalsRef.current.set(chunk.toolCall.id, {
+              toolCallId: chunk.toolCall.id,
+              approved: true
+            });
+          }
+          break;
+        case "tool_result":
+          setActiveToolCalls(
+            (prev) => prev.map(
+              (tc) => tc.id === chunk.toolCall.id ? { ...chunk.toolCall, state: "complete" } : tc
+            )
+          );
+          break;
+        case "tool_state":
+          setActiveToolCalls(
+            (prev) => prev.map(
+              (tc) => tc.id === chunk.toolCallId ? { ...tc, state: chunk.state } : tc
+            )
+          );
+          break;
+        case "done": {
+          setIsStreaming(false);
+          setIsLoading(false);
+          const finalContent = streamingContent;
+          const finalThinking = thinkingContent;
+          const finalToolCalls = [...activeToolCalls];
+          if (finalContent || finalToolCalls.length > 0) {
+            const assistantMessage = createMessage("assistant", finalContent, {
+              toolCalls: finalToolCalls.length > 0 ? finalToolCalls : void 0,
+              thinking: finalThinking ? { type: "thinking", content: finalThinking, isComplete: true } : void 0,
+              metadata: chunk.metadata
+            });
+            setMessages((prev) => [...prev, assistantMessage]);
+            onMessage?.(assistantMessage);
+            onComplete?.(assistantMessage);
+          }
+          setStreamingContent("");
+          setThinkingContent("");
+          setActiveToolCalls([]);
+          retryCountRef.current = 0;
+          break;
+        }
+        case "error": {
+          const err = new Error(chunk.error);
+          setError(err);
+          setIsStreaming(false);
+          setIsLoading(false);
+          onError?.(err);
+          break;
+        }
+      }
+    },
+    [
+      streamingContent,
+      thinkingContent,
+      activeToolCalls,
+      autoApprove,
+      onContentUpdate,
+      onThinking,
+      onToolApproval,
+      onMessage,
+      onComplete,
+      onError
+    ]
+  );
+  const sendMessage = useCallback(
+    async (content) => {
+      if (!content.trim()) return;
+      const userMessage = createMessage("user", content);
+      setMessages((prev) => [...prev, userMessage]);
+      setError(null);
+      setIsLoading(true);
+      setIsStreaming(true);
+      setStreamingContent("");
+      setThinkingContent("");
+      setActiveToolCalls([]);
+      abortControllerRef.current = new AbortController();
+      try {
+        const adapter = adapterRef.current;
+        await adapter.connect(endpoint, {
+          headers,
+          signal: abortControllerRef.current.signal
+        });
+        adapter.onMessage(processChunk);
+        adapter.onError((err) => {
+          setError(err);
+          setIsStreaming(false);
+          setIsLoading(false);
+          onError?.(err);
+        });
+        adapter.onClose(() => {
+          setIsStreaming(false);
+        });
+        const allMessages = [...messages, userMessage];
+        await adapter.send({
+          messages: allMessages,
+          conversationId: conversationIdRef.current,
+          agentId,
+          stream: true,
+          toolApprovals: Array.from(pendingApprovalsRef.current.values())
+        });
+        pendingApprovalsRef.current.clear();
+      } catch (err) {
+        const error2 = err;
+        if (error2.name !== "AbortError") {
+          setError(error2);
+          onError?.(error2);
+          if (retryCountRef.current < maxRetries) {
+            retryCountRef.current++;
+            setMessages((prev) => prev.slice(0, -1));
+            await sendMessage(content);
+            return;
+          }
+        }
+        setIsStreaming(false);
+        setIsLoading(false);
+      }
+    },
+    [endpoint, headers, agentId, messages, processChunk, onError, maxRetries]
+  );
+  const approveToolCall = useCallback((toolCallId) => {
+    pendingApprovalsRef.current.set(toolCallId, {
+      toolCallId,
+      approved: true
+    });
+    setActiveToolCalls(
+      (prev) => prev.map(
+        (tc) => tc.id === toolCallId ? { ...tc, state: "executing" } : tc
+      )
+    );
+  }, []);
+  const denyToolCall = useCallback(
+    (toolCallId, reason) => {
+      pendingApprovalsRef.current.set(toolCallId, {
+        toolCallId,
+        approved: false,
+        reason
+      });
+      setActiveToolCalls(
+        (prev) => prev.map(
+          (tc) => tc.id === toolCallId ? { ...tc, state: "approval-denied" } : tc
+        )
+      );
+    },
+    []
+  );
+  const stop = useCallback(() => {
+    abortControllerRef.current?.abort();
+    adapterRef.current.close();
+    setIsStreaming(false);
+    setIsLoading(false);
+    if (streamingContent) {
+      const partialMessage = createMessage("assistant", streamingContent, {
+        toolCalls: activeToolCalls.length > 0 ? activeToolCalls : void 0,
+        thinking: thinkingContent ? { type: "thinking", content: thinkingContent, isComplete: false } : void 0,
+        metadata: { finishReason: "stopped" }
+      });
+      setMessages((prev) => [...prev, partialMessage]);
+    }
+    setStreamingContent("");
+    setThinkingContent("");
+    setActiveToolCalls([]);
+  }, [streamingContent, thinkingContent, activeToolCalls]);
+  const clear = useCallback(() => {
+    stop();
+    setMessages([]);
+    setError(null);
+    conversationIdRef.current = generateId();
+  }, [stop]);
+  const reload = useCallback(async () => {
+    const lastUserMessageIndex = messages.map((m) => m.role).lastIndexOf("user");
+    if (lastUserMessageIndex === -1) return;
+    const lastUserMessage = messages[lastUserMessageIndex];
+    setMessages((prev) => prev.slice(0, lastUserMessageIndex));
+    await sendMessage(lastUserMessage.content);
+  }, [messages, sendMessage]);
+  return {
+    messages,
+    streamingContent,
+    thinkingContent,
+    activeToolCalls,
+    isLoading,
+    isStreaming,
+    error,
+    sendMessage,
+    approveToolCall,
+    denyToolCall,
+    stop,
+    clear,
+    reload,
+    setMessages
+  };
+}
+
+// src/useAgent.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
+function useAgent(config) {
+  const {
+    endpoint,
+    agentId,
+    headers = {},
+    onStart,
+    onContentUpdate,
+    onToolApproval,
+    onError,
+    onComplete,
+    onThinking
+  } = config;
+  const [content, setContent] = useState2("");
+  const [thinkingContent, setThinkingContent] = useState2("");
+  const [activeToolCalls, setActiveToolCalls] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [isStreaming, setIsStreaming] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [metadata, setMetadata] = useState2(
+    null
+  );
+  const abortControllerRef = useRef2(null);
+  const pendingApprovalsRef = useRef2(
+    /* @__PURE__ */ new Map()
+  );
+  useEffect2(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  async function* executeStream(input, context) {
+    onStart?.();
+    setError(null);
+    setIsLoading(true);
+    setIsStreaming(true);
+    setContent("");
+    setThinkingContent("");
+    setActiveToolCalls([]);
+    setMetadata(null);
+    abortControllerRef.current = new AbortController();
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...headers
+        },
+        body: JSON.stringify({
+          input,
+          agentId,
+          context,
+          stream: true,
+          toolApprovals: Array.from(pendingApprovalsRef.current.values())
+        }),
+        signal: abortControllerRef.current.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error: ${response.status}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("No response body");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let accumulatedContent = "";
+      let accumulatedThinking = "";
+      let reading = true;
+      while (reading) {
+        const { done, value } = await reader.read();
+        if (done) {
+          reading = false;
+          continue;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              setIsStreaming(false);
+              setIsLoading(false);
+              return;
+            }
+            try {
+              const chunk = JSON.parse(data);
+              switch (chunk.type) {
+                case "content":
+                  if (chunk.delta) {
+                    accumulatedContent += chunk.content;
+                  } else {
+                    accumulatedContent = chunk.content;
+                  }
+                  setContent(accumulatedContent);
+                  onContentUpdate?.(chunk.content);
+                  break;
+                case "thinking": {
+                  if (chunk.delta) {
+                    accumulatedThinking += chunk.content;
+                  } else {
+                    accumulatedThinking = chunk.content;
+                  }
+                  setThinkingContent(accumulatedThinking);
+                  const thinking = {
+                    type: "thinking",
+                    content: chunk.content,
+                    isComplete: false
+                  };
+                  onThinking?.(thinking);
+                  break;
+                }
+                case "tool_call":
+                  setActiveToolCalls((prev) => {
+                    const existing = prev.find(
+                      (tc) => tc.id === chunk.toolCall.id
+                    );
+                    if (existing) {
+                      return prev.map(
+                        (tc) => tc.id === chunk.toolCall.id ? chunk.toolCall : tc
+                      );
+                    }
+                    return [...prev, chunk.toolCall];
+                  });
+                  if (chunk.toolCall.needsApproval) {
+                    onToolApproval?.(chunk.toolCall);
+                  }
+                  break;
+                case "tool_result":
+                  setActiveToolCalls(
+                    (prev) => prev.map(
+                      (tc) => tc.id === chunk.toolCall.id ? { ...chunk.toolCall, state: "complete" } : tc
+                    )
+                  );
+                  break;
+                case "tool_state":
+                  setActiveToolCalls(
+                    (prev) => prev.map(
+                      (tc) => tc.id === chunk.toolCallId ? { ...tc, state: chunk.state } : tc
+                    )
+                  );
+                  break;
+                case "done":
+                  setMetadata(chunk.metadata || null);
+                  setIsStreaming(false);
+                  setIsLoading(false);
+                  break;
+                case "error": {
+                  const err = new Error(chunk.error);
+                  setError(err);
+                  setIsStreaming(false);
+                  setIsLoading(false);
+                  onError?.(err);
+                  break;
+                }
+              }
+              yield chunk;
+            } catch {
+            }
+          }
+        }
+      }
+      pendingApprovalsRef.current.clear();
+    } catch (err) {
+      const error2 = err;
+      if (error2.name !== "AbortError") {
+        setError(error2);
+        onError?.(error2);
+      }
+      setIsStreaming(false);
+      setIsLoading(false);
+      throw error2;
+    }
+  }
+  const execute = useCallback2(
+    async (input, context) => {
+      onStart?.();
+      setError(null);
+      setIsLoading(true);
+      setContent("");
+      setThinkingContent("");
+      setActiveToolCalls([]);
+      setMetadata(null);
+      abortControllerRef.current = new AbortController();
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify({
+            input,
+            agentId,
+            context,
+            stream: false,
+            toolApprovals: Array.from(pendingApprovalsRef.current.values())
+          }),
+          signal: abortControllerRef.current.signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error: ${response.status}`);
+        }
+        const result = await response.json();
+        setContent(result.content);
+        setMetadata({
+          tokensUsed: result.metadata?.tokensUsed,
+          latencyMs: result.metadata?.latencyMs,
+          finishReason: result.finishReason
+        });
+        if (result.toolCalls) {
+          setActiveToolCalls(
+            result.toolCalls.map((tc) => ({
+              ...tc,
+              state: "complete"
+            }))
+          );
+        }
+        setIsLoading(false);
+        onComplete?.(result);
+        pendingApprovalsRef.current.clear();
+        return result;
+      } catch (err) {
+        const error2 = err;
+        if (error2.name !== "AbortError") {
+          setError(error2);
+          onError?.(error2);
+        }
+        setIsLoading(false);
+        return null;
+      }
+    },
+    [endpoint, headers, agentId, onStart, onComplete, onError]
+  );
+  const approveToolCall = useCallback2((toolCallId) => {
+    pendingApprovalsRef.current.set(toolCallId, {
+      toolCallId,
+      approved: true
+    });
+    setActiveToolCalls(
+      (prev) => prev.map(
+        (tc) => tc.id === toolCallId ? { ...tc, state: "executing" } : tc
+      )
+    );
+  }, []);
+  const denyToolCall = useCallback2(
+    (toolCallId, reason) => {
+      pendingApprovalsRef.current.set(toolCallId, {
+        toolCallId,
+        approved: false,
+        reason
+      });
+      setActiveToolCalls(
+        (prev) => prev.map(
+          (tc) => tc.id === toolCallId ? { ...tc, state: "approval-denied" } : tc
+        )
+      );
+    },
+    []
+  );
+  const stop = useCallback2(() => {
+    abortControllerRef.current?.abort();
+    setIsStreaming(false);
+    setIsLoading(false);
+  }, []);
+  const reset = useCallback2(() => {
+    stop();
+    setContent("");
+    setThinkingContent("");
+    setActiveToolCalls([]);
+    setError(null);
+    setMetadata(null);
+    pendingApprovalsRef.current.clear();
+  }, [stop]);
+  return {
+    execute,
+    executeStream,
+    content,
+    thinkingContent,
+    activeToolCalls,
+    isLoading,
+    isStreaming,
+    error,
+    metadata,
+    approveToolCall,
+    denyToolCall,
+    stop,
+    reset
+  };
+}
 export {
   AgentResponse,
   StreamingResponse,
+  createHTTPStreamAdapter,
+  createMessage,
+  createSSEAdapter,
+  fetchChat,
+  generateId,
+  getAdapter,
+  useAgent,
+  useChat,
   useFormattedContent,
   useStreamingContent
 };