binario 0.1.0 → 0.2.0

package/dist/react.cjs

@@ -1822,9 +1822,471 @@ function useBinarioSemanticSearch(options = {}) {
   };
 }
 
+// src/client.ts
+var BINARIO_API_URL = "https://binario-api.databin81.workers.dev";
+var Binario = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  constructor(apiKey, options = {}) {
+    if (!apiKey || !apiKey.startsWith("bsk_")) {
+      throw new Error('Invalid API key. Keys should start with "bsk_"');
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl || BINARIO_API_URL;
+    this.timeout = options.timeout || 3e4;
+    this.maxRetries = options.maxRetries || 3;
+  }
+  /**
+   * Simple chat completion
+   */
+  async chat(messageOrMessages, options = {}) {
+    const messages = this.normalizeMessages(messageOrMessages, options.systemPrompt);
+    const response = await this.request("/v1/chat/completions", {
+      messages,
+      model: options.model,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens,
+      tools: options.tools
+    });
+    return response;
+  }
+  /**
+   * Streaming chat - returns async iterator
+   */
+  async *stream(messageOrMessages, options = {}) {
+    const messages = this.normalizeMessages(messageOrMessages, options.systemPrompt);
+    const response = await fetch(`${this.baseUrl}/v1/chat/stream`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({
+        messages,
+        model: options.model,
+        temperature: options.temperature,
+        max_tokens: options.maxTokens,
+        stream: true
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let fullContent = "";
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      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]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content;
+            if (content) {
+              fullContent += content;
+              yield content;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return {
+      id: crypto.randomUUID(),
+      provider: "cloudflare",
+      content: fullContent,
+      model: options.model || "default",
+      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      finishReason: "stop",
+      latency: 0,
+      cached: false
+    };
+  }
+  /**
+   * Stream with callbacks (alternative API)
+   */
+  async streamWithCallbacks(messageOrMessages, options) {
+    const { onToken, onComplete, onError, ...chatOptions } = options;
+    try {
+      let fullContent = "";
+      for await (const token of this.stream(messageOrMessages, chatOptions)) {
+        fullContent += token;
+        onToken?.(token);
+      }
+      const response = {
+        id: crypto.randomUUID(),
+        provider: "cloudflare",
+        content: fullContent,
+        model: chatOptions.model || "default",
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        finishReason: "stop",
+        latency: 0,
+        cached: false
+      };
+      onComplete?.(response);
+      return response;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      onError?.(err);
+      throw err;
+    }
+  }
+  /**
+   * Create an agent with tools
+   */
+  agent(options) {
+    return new BinarioAgent(this, options);
+  }
+  /**
+   * Get current usage
+   */
+  async getUsage() {
+    return this.request("/v1/usage", {}, "GET");
+  }
+  /**
+   * List available models
+   */
+  async listModels() {
+    return this.request("/v1/models", {}, "GET");
+  }
+  // Private helpers
+  normalizeMessages(input, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    if (typeof input === "string") {
+      messages.push({ role: "user", content: input });
+    } else {
+      messages.push(...input);
+    }
+    return messages;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`,
+      "X-Binario-SDK": "js/0.1.0"
+    };
+  }
+  async request(endpoint, body, method = "POST") {
+    let lastError = null;
+    for (let i = 0; i < this.maxRetries; i++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+          method,
+          headers: this.getHeaders(),
+          body: method === "POST" ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({ error: "Unknown error" }));
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("Retry-After");
+            throw new BinarioRateLimitError(
+              error.error || "Rate limit exceeded",
+              retryAfter ? parseInt(retryAfter) : 60
+            );
+          }
+          if (response.status === 402) {
+            throw new BinarioPaymentError(error.error || "Payment required");
+          }
+          throw new Error(error.error || `Request failed: ${response.status}`);
+        }
+        return response.json();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof BinarioPaymentError) {
+          throw error;
+        }
+        if (i < this.maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, Math.pow(2, i) * 1e3));
+        }
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+};
+var BinarioAgent = class {
+  client;
+  options;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+  /**
+   * Run the agent with a user message
+   */
+  async run(message) {
+    const response = await this.client.request("/v1/agents/run", {
+      message,
+      name: this.options.name,
+      systemPrompt: this.options.systemPrompt,
+      tools: this.options.tools,
+      maxIterations: this.options.maxIterations || 10,
+      model: this.options.model
+    });
+    return response;
+  }
+  /**
+   * Run agent with streaming
+   */
+  async *runStream(message) {
+    const response = await fetch(`${this.client.baseUrl}/v1/agents/stream`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({
+        message,
+        name: this.options.name,
+        systemPrompt: this.options.systemPrompt,
+        tools: this.options.tools,
+        maxIterations: this.options.maxIterations || 10,
+        model: this.options.model
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Agent request failed: ${response.status}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      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]") continue;
+          try {
+            yield JSON.parse(data);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+var BinarioRateLimitError = class extends Error {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "BinarioRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var BinarioPaymentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BinarioPaymentError";
+  }
+};
+
+// src/client-hooks.ts
+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 };
+}
+
+exports.BinarioProvider = BinarioProvider;
+exports.useAgent = useAgent;
 exports.useBinarioAgent = useBinarioAgent;
 exports.useBinarioChat = useBinarioChat;
 exports.useBinarioChatWithMemory = useBinarioChatWithMemory;
+exports.useBinarioClient = useBinarioClient;
 exports.useBinarioCompletion = useBinarioCompletion;
 exports.useBinarioEmbed = useBinarioEmbed;
 exports.useBinarioMemory = useBinarioMemory;
@@ -1832,5 +2294,8 @@ exports.useBinarioSemanticSearch = useBinarioSemanticSearch;
 exports.useBinarioStream = useBinarioStream;
 exports.useBinarioStructured = useBinarioStructured;
 exports.useBinarioTools = useBinarioTools;
+exports.useChat = useChat;
+exports.useStream = useStream;
+exports.useUsage = useUsage;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map