binario 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -2390,6 +2390,187 @@ function useBinarioAgent(agent, options = {}) {
     stop
   };
 }
+var BinarioContext = react.createContext(null);
+function BinarioProvider({ apiKey, baseUrl, children }) {
+  const clientRef = react.useRef(null);
+  if (!clientRef.current || clientRef.current.apiKey !== apiKey) {
+    clientRef.current = new Binario(apiKey, { baseUrl });
+  }
+  return (
+    // @ts-ignore - React.createElement for compatibility
+    BinarioContext.Provider({ value: { client: clientRef.current } }, children)
+  );
+}
+function useBinarioClient() {
+  const context = react.useContext(BinarioContext);
+  if (!context) {
+    throw new Error("useBinarioClient must be used within a BinarioProvider");
+  }
+  return context.client;
+}
+function useChat(client, options = {}) {
+  const [messages, setMessages] = react.useState(options.initialMessages || []);
+  const [input, setInput] = react.useState("");
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const abortRef = react.useRef(false);
+  const stop = react.useCallback(() => {
+    abortRef.current = true;
+    setIsLoading(false);
+  }, []);
+  const send = react.useCallback(async (content) => {
+    const messageContent = content || input;
+    if (!messageContent.trim()) return;
+    setIsLoading(true);
+    setError(null);
+    abortRef.current = false;
+    const userMessage = { role: "user", content: messageContent };
+    const newMessages = [...messages, userMessage];
+    setMessages(newMessages);
+    setInput("");
+    try {
+      const response = await client.chat(newMessages, {
+        model: options.model,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        systemPrompt: options.systemPrompt
+      });
+      if (abortRef.current) return;
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content || response.choices?.[0]?.message?.content || ""
+      };
+      setMessages([...newMessages, assistantMessage]);
+      options.onFinish?.(response);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      options.onError?.(e);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [messages, input, client, options]);
+  return { messages, input, setInput, isLoading, error, send, setMessages, stop };
+}
+function useStream(client, options = {}) {
+  const [messages, setMessages] = react.useState(options.initialMessages || []);
+  const [input, setInput] = react.useState("");
+  const [isStreaming, setIsStreaming] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [streamingContent, setStreamingContent] = react.useState("");
+  const abortRef = react.useRef(false);
+  const stop = react.useCallback(() => {
+    abortRef.current = true;
+    setIsStreaming(false);
+  }, []);
+  const send = react.useCallback(async (content) => {
+    const messageContent = content || input;
+    if (!messageContent.trim()) return;
+    setIsStreaming(true);
+    setError(null);
+    setStreamingContent("");
+    abortRef.current = false;
+    const userMessage = { role: "user", content: messageContent };
+    const newMessages = [...messages, userMessage];
+    setMessages(newMessages);
+    setInput("");
+    let fullContent = "";
+    try {
+      for await (const token of client.stream(newMessages, {
+        model: options.model,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        systemPrompt: options.systemPrompt
+      })) {
+        if (abortRef.current) break;
+        fullContent += token;
+        setStreamingContent(fullContent);
+        options.onToken?.(token);
+      }
+      if (!abortRef.current) {
+        const assistantMessage = { role: "assistant", content: fullContent };
+        setMessages([...newMessages, assistantMessage]);
+        setStreamingContent("");
+        options.onFinish?.({ content: fullContent });
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      options.onError?.(e);
+    } finally {
+      setIsStreaming(false);
+    }
+  }, [messages, input, client, options]);
+  return { messages, input, setInput, isStreaming, error, streamingContent, send, setMessages, stop };
+}
+function useAgent(client, options) {
+  const [output, setOutput] = react.useState("");
+  const [isRunning, setIsRunning] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [toolCalls, setToolCalls] = react.useState([]);
+  const abortRef = react.useRef(false);
+  const stop = react.useCallback(() => {
+    abortRef.current = true;
+    setIsRunning(false);
+  }, []);
+  const run = react.useCallback(async (message) => {
+    setIsRunning(true);
+    setError(null);
+    setOutput("");
+    setToolCalls([]);
+    abortRef.current = false;
+    try {
+      const agent = client.agent({
+        name: options.name,
+        systemPrompt: options.systemPrompt,
+        tools: options.tools,
+        maxIterations: options.maxIterations,
+        model: options.model
+      });
+      const result = await agent.run(message);
+      if (abortRef.current) return null;
+      setOutput(result.output || "");
+      if (result.toolCalls) {
+        const calls = result.toolCalls.map((tc) => ({
+          tool: tc.tool || tc.name,
+          args: tc.args || tc.arguments
+        }));
+        setToolCalls(calls);
+        calls.forEach((tc) => options.onToolCall?.(tc.tool, tc.args));
+      }
+      return result.output || "";
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      options.onError?.(e);
+      return null;
+    } finally {
+      setIsRunning(false);
+    }
+  }, [client, options]);
+  return { output, isRunning, error, toolCalls, run, stop };
+}
+function useUsage(client) {
+  const [usage, setUsage] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const refresh = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await client.getUsage();
+      setUsage(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    refresh();
+  }, [refresh]);
+  return { usage, isLoading, error, refresh };
+}
 
 // src/observability.ts
 var consoleHooks = {
@@ -2432,6 +2613,7 @@ exports.Binario = Binario;
 exports.BinarioAI = BinarioAI;
 exports.BinarioAgent = BinarioAgent;
 exports.BinarioPaymentError = BinarioPaymentError;
+exports.BinarioProvider = BinarioProvider;
 exports.BinarioRateLimitError = BinarioRateLimitError;
 exports.BufferMemory = BufferMemory;
 exports.CLOUDFLARE_EMBEDDING_MODELS = CLOUDFLARE_EMBEDDING_MODELS;
@@ -2470,7 +2652,12 @@ exports.generateId = generateId;
 exports.parseStructuredOutput = parseStructuredOutput;
 exports.truncateMessages = truncateMessages;
 exports.truncateMessagesByCount = truncateMessagesByCount;
+exports.useAgent = useAgent;
 exports.useBinarioAgent = useBinarioAgent;
+exports.useBinarioClient = useBinarioClient;
+exports.useChat = useChat;
+exports.useStream = useStream;
+exports.useUsage = useUsage;
 exports.zodToJsonSchema = zodToJsonSchema;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map