binario 0.1.0

package/dist/react.d.ts

@@ -0,0 +1,555 @@
+import { z } from 'zod';
+
+type Provider = 'openai' | 'anthropic' | 'google' | 'mistral' | 'cohere' | 'cloudflare' | 'lovable';
+interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    images?: string[];
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface Tool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface StreamCallbacks {
+    onToken?: (token: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+    onComplete?: (response: ChatResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface ChatOptions {
+    provider?: Provider;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    stop?: string[];
+    tools?: Tool[];
+    toolChoice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    stream?: boolean;
+    timeout?: number;
+    retries?: number;
+    cache?: boolean;
+    cacheKey?: string;
+    cacheTTL?: number;
+    outputSchema?: z.ZodType<unknown>;
+}
+interface ChatResponse {
+    id: string;
+    provider: Provider;
+    model: string;
+    content: string;
+    toolCalls?: ToolCall[];
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    latency: number;
+    cached: boolean;
+    data?: unknown;
+}
+interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+    headers?: Record<string, string>;
+    binding?: unknown;
+    accountId?: string;
+}
+interface BinarioConfig {
+    providers: Partial<Record<Provider, ProviderConfig>>;
+    defaultProvider?: Provider;
+    cache?: {
+        enabled: boolean;
+        ttl?: number;
+        maxSize?: number;
+    };
+    retry?: {
+        maxRetries: number;
+        backoff: 'linear' | 'exponential';
+        initialDelay: number;
+    };
+    timeout?: number;
+    debug?: boolean;
+}
+interface AgentTool<TContext = unknown, TArgs = unknown, TResult = unknown> {
+    name: string;
+    description: string;
+    parameters: z.ZodType<TArgs>;
+    execute: (args: TArgs, context: TContext) => Promise<TResult> | TResult;
+}
+interface AgentConfig<TContext = unknown, TDeps = unknown> {
+    name?: string;
+    model?: string;
+    provider?: Provider;
+    systemPrompt?: string | ((context: TContext) => string);
+    tools?: AgentTool<TContext>[];
+    maxIterations?: number;
+    dependencies?: TDeps;
+    outputSchema?: z.ZodType<unknown>;
+}
+interface AgentRunOptions {
+    maxIterations?: number;
+    maxSteps?: number;
+    onToolCall?: (tool: string, args: unknown, result: unknown) => void;
+    onThinking?: (content: string) => void;
+    onStep?: (step: {
+        type: string;
+        content: string;
+    }) => void;
+    signal?: AbortSignal;
+}
+interface AgentResult<T = string> {
+    output: T;
+    messages: Message[];
+    toolCalls: Array<{
+        tool: string;
+        args: unknown;
+        result: unknown;
+    }>;
+    iterations: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+
+declare class BinarioAI {
+    private config;
+    private cache;
+    constructor(config: BinarioConfig);
+    private getProvider;
+    private getProviderConfig;
+    private retryWithBackoff;
+    private formatMessagesForProvider;
+    private parseProviderResponse;
+    chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
+    private handleStructuredOutput;
+    streamChat(messages: Message[], options?: ChatOptions, callbacks?: StreamCallbacks): AsyncGenerator<string, ChatResponse, unknown>;
+    clearCache(): void;
+}
+
+/**
+ * Agent class for multi-step reasoning with tools
+ *
+ * @example
+ * const agent = createAgent({
+ *   model: 'cloudflare:llama-3.3-70b',
+ *   systemPrompt: 'You are a helpful assistant',
+ *   tools: [searchTool, calculatorTool],
+ * });
+ *
+ * const result = await agent.run('What is the weather in Tokyo?', {
+ *   onToolCall: (tool, args, result) => console.log(`Called ${tool}`)
+ * });
+ */
+declare class Agent<TContext = unknown, TDeps = unknown> {
+    private binario;
+    private config;
+    private context;
+    constructor(binario: BinarioAI, config: AgentConfig<TContext, TDeps>, context?: TContext);
+    /**
+     * Set the agent context (for dependency injection)
+     */
+    withContext(context: TContext): Agent<TContext, TDeps>;
+    /**
+     * Get the system prompt (can be dynamic based on context)
+     */
+    private getSystemPrompt;
+    /**
+     * Convert tools to LLM-compatible format
+     */
+    private getToolsForLLM;
+    /**
+     * Execute a tool call
+     */
+    private executeTool;
+    /**
+     * Run the agent with a user message
+     */
+    run(input: string, options?: AgentRunOptions): Promise<AgentResult<string>>;
+    /**
+     * Run the agent with structured output
+     */
+    runStructured<T>(input: string, schema: z.ZodType<T>, options?: AgentRunOptions): Promise<AgentResult<T>>;
+    /**
+     * Stream the agent's response
+     */
+    stream(input: string, options?: AgentRunOptions): AsyncGenerator<{
+        type: 'token' | 'tool_call' | 'complete';
+        content: string;
+        data?: unknown;
+    }>;
+}
+
+/** Stored message with metadata */
+interface StoredMessage {
+    id: string;
+    message: Message;
+    timestamp: number;
+    conversationId: string;
+    tokenCount?: number;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+/** Conversation context for LLM */
+interface ConversationContext {
+    messages: Message[];
+    summary?: string;
+    tokenCount: number;
+    messageCount: number;
+}
+/** Memory store interface for persistence */
+interface MemoryStore {
+    /** Get all messages for a conversation */
+    getMessages(conversationId: string): Promise<StoredMessage[]>;
+    /** Add a message to storage */
+    addMessage(message: StoredMessage): Promise<void>;
+    /** Update an existing message */
+    updateMessage(id: string, updates: Partial<StoredMessage>): Promise<void>;
+    /** Delete a message */
+    deleteMessage(id: string): Promise<void>;
+    /** Clear all messages for a conversation */
+    clear(conversationId: string): Promise<void>;
+    /** Get conversation metadata (e.g., summary) */
+    getMetadata(conversationId: string): Promise<Record<string, unknown> | null>;
+    /** Set conversation metadata */
+    setMetadata(conversationId: string, metadata: Record<string, unknown>): Promise<void>;
+}
+/** Base memory interface */
+interface Memory {
+    /** Memory type identifier */
+    readonly type: 'buffer' | 'summary' | 'summary-buffer' | 'vector';
+    /** Add a message to memory */
+    add(message: Message): Promise<void>;
+    /** Add multiple messages at once */
+    addMany(messages: Message[]): Promise<void>;
+    /** Get messages formatted for LLM context */
+    getMessages(): Promise<Message[]>;
+    /** Get full context including summary and token info */
+    getContext(): Promise<ConversationContext>;
+    /** Get context window limited by tokens */
+    getContextWindow(maxTokens: number): Promise<ConversationContext>;
+    /** Clear all memory */
+    clear(): Promise<void>;
+    /** Get current message count */
+    getMessageCount(): Promise<number>;
+    /** Get estimated token count */
+    getTokenCount(): Promise<number>;
+}
+
+/** Summarizer function type */
+type SummarizerFn = (messages: Message[], prompt: string) => Promise<string>;
+
+/** Embedding result for a single text */
+interface EmbeddingResult {
+    /** The input text */
+    text: string;
+    /** The embedding vector */
+    embedding: number[];
+    /** Token count used */
+    tokenCount?: number;
+}
+/** Batch embedding result */
+interface BatchEmbeddingResult {
+    /** Array of embedding results */
+    embeddings: EmbeddingResult[];
+    /** Model used */
+    model: string;
+    /** Total tokens used */
+    usage: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+/** Embeddings provider interface */
+interface EmbeddingsProvider {
+    /** Provider name */
+    readonly name: string;
+    /** Embed a single text */
+    embed(text: string): Promise<EmbeddingResult>;
+    /** Embed multiple texts */
+    embedMany(texts: string[]): Promise<BatchEmbeddingResult>;
+}
+
+interface UseBinarioChatOptions extends ChatOptions {
+    initialMessages?: Message[];
+    onFinish?: (response: ChatResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface UseBinarioChatReturn {
+    messages: Message[];
+    input: string;
+    setInput: (input: string) => void;
+    isLoading: boolean;
+    error: Error | null;
+    append: (message: Message) => Promise<void>;
+    reload: () => Promise<void>;
+    stop: () => void;
+    setMessages: (messages: Message[]) => void;
+    lastResponse: ChatResponse | null;
+}
+declare function useBinarioChat(binario: BinarioAI, options?: UseBinarioChatOptions): UseBinarioChatReturn;
+interface UseBinarioStreamOptions extends ChatOptions {
+    initialMessages?: Message[];
+    onToken?: (token: string) => void;
+    onFinish?: (response: ChatResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface UseBinarioStreamReturn {
+    messages: Message[];
+    input: string;
+    setInput: (input: string) => void;
+    isStreaming: boolean;
+    error: Error | null;
+    streamingContent: string;
+    send: (content: string) => Promise<void>;
+    stop: () => void;
+    setMessages: (messages: Message[]) => void;
+}
+declare function useBinarioStream(binario: BinarioAI, options?: UseBinarioStreamOptions): UseBinarioStreamReturn;
+interface UseBinarioCompletionOptions extends ChatOptions {
+    onFinish?: (response: ChatResponse) => void;
+    onError?: (error: Error) => void;
+}
+declare function useBinarioCompletion(binario: BinarioAI, options?: UseBinarioCompletionOptions): {
+    completion: string;
+    isLoading: boolean;
+    error: Error | null;
+    complete: (prompt: string, systemPrompt?: string) => Promise<string | null>;
+};
+interface UseBinarioAgentOptions {
+    onStep?: (step: {
+        type: string;
+        content: string;
+    }) => void;
+    onToolCall?: (tool: {
+        name: string;
+        args: unknown;
+    }) => void;
+    onError?: (error: Error) => void;
+    maxSteps?: number;
+}
+interface UseBinarioAgentReturn<TContext> {
+    output: string;
+    isRunning: boolean;
+    error: Error | null;
+    steps: Array<{
+        type: string;
+        content: string;
+    }>;
+    run: (input: string, context?: TContext) => Promise<string | null>;
+    runStructured: <T>(input: string, schema: z.ZodType<T>, context?: TContext) => Promise<T | null>;
+    stop: () => void;
+}
+declare function useBinarioAgent<TContext = unknown, TDeps = unknown>(agent: Agent<TContext, TDeps>, options?: UseBinarioAgentOptions): UseBinarioAgentReturn<TContext>;
+interface UseBinarioStructuredOptions<T> extends ChatOptions {
+    schema: z.ZodType<T>;
+    onFinish?: (data: T) => void;
+    onError?: (error: Error) => void;
+}
+interface UseBinarioStructuredReturn<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    generate: (prompt: string, systemPrompt?: string) => Promise<T | null>;
+}
+declare function useBinarioStructured<T>(binario: BinarioAI, options: UseBinarioStructuredOptions<T>): UseBinarioStructuredReturn<T>;
+interface HookTool {
+    name: string;
+    description: string;
+    parameters: z.ZodType<unknown>;
+    execute: (args: unknown) => Promise<unknown> | unknown;
+}
+interface UseBinarioToolsOptions {
+    tools: HookTool[];
+    provider?: string;
+    model?: string;
+    onToolCall?: (name: string, args: unknown) => void;
+    onToolResult?: (name: string, result: unknown) => void;
+    onError?: (error: Error) => void;
+}
+interface UseBinarioToolsReturn {
+    messages: Message[];
+    isProcessing: boolean;
+    error: Error | null;
+    send: (content: string) => Promise<void>;
+    setMessages: (messages: Message[]) => void;
+}
+declare function useBinarioTools(binario: BinarioAI, options: UseBinarioToolsOptions): UseBinarioToolsReturn;
+
+type MemoryType = 'buffer' | 'summary' | 'summary-buffer' | 'vector';
+interface UseBinarioMemoryOptions {
+    /** Memory type to use */
+    type?: MemoryType;
+    /** Conversation ID (auto-generated if not provided) */
+    conversationId?: string;
+    /** Storage backend: 'memory' | 'localStorage' | custom MemoryStore */
+    store?: 'memory' | 'localStorage' | MemoryStore;
+    /** LocalStorage prefix (only for localStorage store) */
+    storagePrefix?: string;
+    /** Max messages to keep (for buffer/summary-buffer) */
+    maxMessages?: number;
+    /** Max tokens to keep */
+    maxTokens?: number;
+    /** Buffer size for summary-buffer memory */
+    bufferSize?: number;
+    /** Summarizer function (required for summary/summary-buffer) */
+    summarizer?: SummarizerFn;
+    /** Embeddings provider (required for vector memory) */
+    embeddings?: EmbeddingsProvider;
+    /** Top K results for vector search */
+    topK?: number;
+    /** Min similarity score for vector search */
+    minScore?: number;
+}
+interface UseBinarioMemoryReturn {
+    /** The memory instance */
+    memory: Memory;
+    /** Current messages in memory */
+    messages: Message[];
+    /** Current context (messages + summary + token count) */
+    context: ConversationContext | null;
+    /** Whether memory is loading */
+    isLoading: boolean;
+    /** Add a message to memory */
+    addMessage: (message: Message) => Promise<void>;
+    /** Add multiple messages */
+    addMessages: (messages: Message[]) => Promise<void>;
+    /** Clear all messages */
+    clear: () => Promise<void>;
+    /** Refresh messages from memory */
+    refresh: () => Promise<void>;
+    /** Get context window with token limit */
+    getContextWindow: (maxTokens: number) => Promise<ConversationContext>;
+    /** Current conversation ID */
+    conversationId: string;
+    /** Switch to a different conversation */
+    switchConversation: (id: string) => void;
+}
+declare function useBinarioMemory(options?: UseBinarioMemoryOptions): UseBinarioMemoryReturn;
+interface UseBinarioChatWithMemoryOptions extends UseBinarioChatOptions {
+    /** Memory options */
+    memory?: UseBinarioMemoryOptions;
+    /** Auto-save messages to memory */
+    autoSave?: boolean;
+    /** Context window size in tokens */
+    contextWindowSize?: number;
+}
+interface UseBinarioChatWithMemoryReturn extends UseBinarioChatReturn {
+    /** Memory state and controls */
+    memory: UseBinarioMemoryReturn;
+    /** Load conversation from memory */
+    loadConversation: (conversationId?: string) => Promise<void>;
+    /** Save current conversation to memory */
+    saveConversation: () => Promise<void>;
+}
+declare function useBinarioChatWithMemory(binario: BinarioAI, options?: UseBinarioChatWithMemoryOptions): UseBinarioChatWithMemoryReturn;
+
+type EmbeddingsProviderType = 'cloudflare' | 'custom';
+interface UseBinarioEmbedOptions {
+    /** Embeddings provider type */
+    provider?: EmbeddingsProviderType;
+    /** Custom embeddings provider instance */
+    customProvider?: EmbeddingsProvider;
+    /** Model to use (provider-specific) */
+    model?: string;
+    /** Cloudflare account ID (for REST API) */
+    accountId?: string;
+    /** Cloudflare API key (for REST API) */
+    apiKey?: string;
+    /** Cache embeddings in memory */
+    cache?: boolean;
+    /** Callback when embedding starts */
+    onStart?: () => void;
+    /** Callback when embedding completes */
+    onComplete?: (result: EmbeddingResult | BatchEmbeddingResult) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseBinarioEmbedReturn {
+    /** Generate embedding for a single text */
+    embed: (text: string) => Promise<EmbeddingResult | null>;
+    /** Generate embeddings for multiple texts */
+    embedMany: (texts: string[]) => Promise<BatchEmbeddingResult | null>;
+    /** Calculate similarity between two texts */
+    similarity: (text1: string, text2: string) => Promise<number | null>;
+    /** Find most similar texts from a list */
+    findSimilar: (query: string, candidates: string[], topK?: number) => Promise<Array<{
+        text: string;
+        score: number;
+    }> | null>;
+    /** Current embedding result */
+    result: EmbeddingResult | null;
+    /** Batch embedding results */
+    batchResult: BatchEmbeddingResult | null;
+    /** Whether embedding is in progress */
+    isLoading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Clear cached embeddings */
+    clearCache: () => void;
+    /** Get embedding from cache */
+    getCached: (text: string) => number[] | null;
+}
+declare function useBinarioEmbed(options?: UseBinarioEmbedOptions): UseBinarioEmbedReturn;
+interface UseBinarioSemanticSearchOptions extends UseBinarioEmbedOptions {
+    /** Minimum similarity score to include in results */
+    minScore?: number;
+    /** Maximum number of results to return */
+    maxResults?: number;
+}
+interface SearchDocument {
+    id: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+interface SearchResult {
+    document: SearchDocument;
+    score: number;
+}
+interface UseBinarioSemanticSearchReturn {
+    /** Add documents to the search index */
+    addDocuments: (documents: SearchDocument[]) => Promise<void>;
+    /** Search for similar documents */
+    search: (query: string) => Promise<SearchResult[]>;
+    /** Remove documents by ID */
+    removeDocuments: (ids: string[]) => void;
+    /** Clear all documents */
+    clear: () => void;
+    /** Number of indexed documents */
+    documentCount: number;
+    /** Whether indexing is in progress */
+    isIndexing: boolean;
+    /** Whether search is in progress */
+    isSearching: boolean;
+    /** Error if any */
+    error: Error | null;
+}
+declare function useBinarioSemanticSearch(options?: UseBinarioSemanticSearchOptions): UseBinarioSemanticSearchReturn;
+
+export { type EmbeddingsProviderType, type HookTool, type MemoryType, type SearchDocument, type SearchResult, type UseBinarioAgentOptions, type UseBinarioAgentReturn, type UseBinarioChatOptions, type UseBinarioChatReturn, type UseBinarioChatWithMemoryOptions, type UseBinarioChatWithMemoryReturn, type UseBinarioCompletionOptions, type UseBinarioEmbedOptions, type UseBinarioEmbedReturn, type UseBinarioMemoryOptions, type UseBinarioMemoryReturn, type UseBinarioSemanticSearchOptions, type UseBinarioSemanticSearchReturn, type UseBinarioStreamOptions, type UseBinarioStreamReturn, type UseBinarioStructuredOptions, type UseBinarioStructuredReturn, type UseBinarioToolsOptions, type UseBinarioToolsReturn, useBinarioAgent, useBinarioChat, useBinarioChatWithMemory, useBinarioCompletion, useBinarioEmbed, useBinarioMemory, useBinarioSemanticSearch, useBinarioStream, useBinarioStructured, useBinarioTools };