binario 0.1.0

package/dist/react.js

@@ -0,0 +1,1825 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { z } from 'zod';
+
+// src/hooks.ts
+function zodToJsonSchema(schema) {
+  return convertZodToJson(schema);
+}
+function convertZodToJson(schema) {
+  const def = schema._def;
+  const result = {};
+  const desc = def && def.description || schema.description;
+  if (desc && typeof desc === "string") {
+    result.description = desc;
+  }
+  if (schema instanceof z.ZodString) {
+    result.type = "string";
+  } else if (schema instanceof z.ZodNumber) {
+    result.type = "number";
+  } else if (schema instanceof z.ZodBoolean) {
+    result.type = "boolean";
+  } else if (schema instanceof z.ZodArray) {
+    result.type = "array";
+    const innerType = def.type || def.element || schema._def?.type || schema.element;
+    if (innerType) {
+      result.items = convertZodToJson(innerType);
+    }
+  } else if (schema instanceof z.ZodObject) {
+    result.type = "object";
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      properties[key] = convertZodToJson(value);
+      if (!(value instanceof z.ZodOptional)) {
+        required.push(key);
+      }
+    }
+    result.properties = properties;
+    if (required.length > 0) {
+      result.required = required;
+    }
+  } else if (schema instanceof z.ZodEnum) {
+    result.type = "string";
+    result.enum = def.values || schema.options || schema._def?.values;
+  } else if (schema instanceof z.ZodOptional) {
+    return convertZodToJson(schema._def.innerType);
+  } else if (schema instanceof z.ZodNullable) {
+    const inner = convertZodToJson(schema._def.innerType);
+    return { ...inner, nullable: true };
+  } else if (schema instanceof z.ZodDefault) {
+    const defaultDef = schema._def;
+    const inner = convertZodToJson(defaultDef.innerType);
+    return { ...inner, default: typeof defaultDef.defaultValue === "function" ? defaultDef.defaultValue() : defaultDef.defaultValue };
+  } else if (schema instanceof z.ZodUnion) {
+    result.oneOf = schema._def.options.map(convertZodToJson);
+  } else if (schema instanceof z.ZodLiteral) {
+    const litDef = schema._def;
+    result.const = litDef.value ?? litDef.values;
+  } else if (schema instanceof z.ZodRecord) {
+    result.type = "object";
+    result.additionalProperties = convertZodToJson(schema._def.valueType);
+  } else if (schema instanceof z.ZodTuple) {
+    result.type = "array";
+    result.items = schema._def.items.map(convertZodToJson);
+  } else {
+    result.type = "string";
+  }
+  return result;
+}
+
+// src/memory/utils.ts
+function countTokens(text) {
+  if (!text) return 0;
+  const words = text.split(/\s+/).filter(Boolean);
+  const avgCharsPerWord = text.length / Math.max(words.length, 1);
+  const ratio = avgCharsPerWord > 6 ? 3.5 : 4;
+  return Math.ceil(text.length / ratio);
+}
+function countMessageTokens(message) {
+  let tokens = 0;
+  tokens += 4;
+  tokens += countTokens(message.content);
+  if (message.name) {
+    tokens += countTokens(message.name) + 1;
+  }
+  if (message.tool_calls) {
+    for (const call of message.tool_calls) {
+      tokens += countTokens(call.function.name);
+      tokens += countTokens(call.function.arguments);
+      tokens += 10;
+    }
+  }
+  return tokens;
+}
+function countMessagesTokens(messages) {
+  return messages.reduce((sum, msg) => sum + countMessageTokens(msg), 0);
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function createStoredMessage(message, conversationId, options) {
+  return {
+    id: generateId(),
+    message,
+    timestamp: Date.now(),
+    conversationId,
+    tokenCount: countMessageTokens(message),
+    embedding: options?.embedding,
+    metadata: options?.metadata
+  };
+}
+function truncateMessages(messages, maxTokens, options) {
+  const { keepSystemMessages = true } = options ?? {};
+  const systemMessages = keepSystemMessages ? messages.filter((m) => m.role === "system") : [];
+  const nonSystemMessages = keepSystemMessages ? messages.filter((m) => m.role !== "system") : [...messages];
+  const systemTokens = countMessagesTokens(systemMessages);
+  const remainingTokens = maxTokens - systemTokens;
+  if (remainingTokens <= 0) {
+    return truncateMessagesSimple(messages, maxTokens);
+  }
+  const truncated = truncateMessagesSimple(nonSystemMessages, remainingTokens);
+  return [...systemMessages, ...truncated];
+}
+function truncateMessagesSimple(messages, maxTokens) {
+  let totalTokens = 0;
+  const result = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msgTokens = countMessageTokens(messages[i]);
+    if (totalTokens + msgTokens > maxTokens) {
+      break;
+    }
+    totalTokens += msgTokens;
+    result.unshift(messages[i]);
+  }
+  return result;
+}
+function truncateMessagesByCount(messages, maxMessages, options) {
+  const { keepSystemMessages = true } = options ?? {};
+  if (messages.length <= maxMessages) {
+    return messages;
+  }
+  if (keepSystemMessages) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const remainingSlots = maxMessages - systemMessages.length;
+    if (remainingSlots <= 0) {
+      return systemMessages.slice(-maxMessages);
+    }
+    return [...systemMessages, ...nonSystemMessages.slice(-remainingSlots)];
+  }
+  return messages.slice(-maxMessages);
+}
+function createContext(messages, summary) {
+  return {
+    messages,
+    summary: summary ?? void 0,
+    tokenCount: countMessagesTokens(messages),
+    messageCount: messages.length
+  };
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0) return 0;
+  return dotProduct / magnitude;
+}
+var DEFAULT_SUMMARY_PROMPT = `Summarize the following conversation concisely, preserving key information, decisions, and context that would be useful for continuing the conversation. Focus on:
+- Main topics discussed
+- Key decisions or conclusions
+- Important user preferences or requirements
+- Any pending questions or tasks
+
+Conversation:
+{conversation}
+
+Summary:`;
+function formatConversationForSummary(messages) {
+  return messages.filter((m) => m.role !== "system").map((m) => `${m.role.toUpperCase()}: ${m.content}`).join("\n\n");
+}
+
+// src/memory/stores/in-memory.ts
+var InMemoryStore = class {
+  messages = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  async getMessages(conversationId) {
+    return this.messages.get(conversationId) ?? [];
+  }
+  async addMessage(message) {
+    const messages = this.messages.get(message.conversationId) ?? [];
+    messages.push(message);
+    this.messages.set(message.conversationId, messages);
+  }
+  async updateMessage(id, updates) {
+    for (const [conversationId, messages] of this.messages) {
+      const index = messages.findIndex((m) => m.id === id);
+      if (index !== -1) {
+        messages[index] = { ...messages[index], ...updates };
+        this.messages.set(conversationId, messages);
+        return;
+      }
+    }
+  }
+  async deleteMessage(id) {
+    for (const [conversationId, messages] of this.messages) {
+      const filtered = messages.filter((m) => m.id !== id);
+      if (filtered.length !== messages.length) {
+        this.messages.set(conversationId, filtered);
+        return;
+      }
+    }
+  }
+  async clear(conversationId) {
+    this.messages.delete(conversationId);
+    this.metadata.delete(conversationId);
+  }
+  async getMetadata(conversationId) {
+    return this.metadata.get(conversationId) ?? null;
+  }
+  async setMetadata(conversationId, metadata) {
+    this.metadata.set(conversationId, metadata);
+  }
+  /** Clear all data (useful for testing) */
+  clearAll() {
+    this.messages.clear();
+    this.metadata.clear();
+  }
+  /** Get all conversation IDs */
+  getConversationIds() {
+    return Array.from(this.messages.keys());
+  }
+};
+
+// src/memory/buffer.ts
+var DEFAULT_MAX_MESSAGES = 50;
+var DEFAULT_MAX_TOKENS = 4e3;
+var BufferMemory = class {
+  type = "buffer";
+  store;
+  conversationId;
+  maxMessages;
+  maxTokens;
+  includeSystemMessages;
+  strategy;
+  constructor(options = {}) {
+    this.store = options.store ?? new InMemoryStore();
+    this.conversationId = options.conversationId ?? generateId();
+    this.maxMessages = options.maxMessages ?? DEFAULT_MAX_MESSAGES;
+    this.maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.includeSystemMessages = options.includeSystemMessages ?? true;
+    this.strategy = options.strategy ?? "sliding";
+  }
+  async add(message) {
+    const stored = createStoredMessage(message, this.conversationId);
+    await this.store.addMessage(stored);
+    await this.trim();
+  }
+  async addMany(messages) {
+    for (const message of messages) {
+      const stored = createStoredMessage(message, this.conversationId);
+      await this.store.addMessage(stored);
+    }
+    await this.trim();
+  }
+  async getMessages() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return this.extractMessages(stored);
+  }
+  async getContext() {
+    const messages = await this.getMessages();
+    return createContext(messages);
+  }
+  async getContextWindow(maxTokens) {
+    const messages = await this.getMessages();
+    const truncated = truncateMessages(messages, maxTokens, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    return createContext(truncated);
+  }
+  async clear() {
+    await this.store.clear(this.conversationId);
+  }
+  async getMessageCount() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return stored.length;
+  }
+  async getTokenCount() {
+    const messages = await this.getMessages();
+    return countMessagesTokens(messages);
+  }
+  /** Get the conversation ID */
+  getConversationId() {
+    return this.conversationId;
+  }
+  /** Switch to a different conversation */
+  setConversationId(id) {
+    this.conversationId = id;
+  }
+  extractMessages(stored) {
+    return stored.sort((a, b) => a.timestamp - b.timestamp).map((s) => s.message);
+  }
+  async trim() {
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    let trimmed = truncateMessagesByCount(messages, this.maxMessages, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    trimmed = truncateMessages(trimmed, this.maxTokens, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    if (trimmed.length < messages.length) {
+      await this.store.clear(this.conversationId);
+      for (const message of trimmed) {
+        const storedMsg = createStoredMessage(message, this.conversationId);
+        await this.store.addMessage(storedMsg);
+      }
+    }
+  }
+};
+
+// src/memory/summary.ts
+var DEFAULT_SUMMARIZE_THRESHOLD = 2e3;
+var DEFAULT_SUMMARY_MODEL = "google/gemini-2.5-flash";
+var SummaryMemory = class {
+  type = "summary";
+  store;
+  conversationId;
+  summarizeThreshold;
+  summaryModel;
+  summaryPrompt;
+  summarizer;
+  includeSystemMessages;
+  constructor(options = {}) {
+    this.store = options.store ?? new InMemoryStore();
+    this.conversationId = options.conversationId ?? generateId();
+    this.summarizeThreshold = options.summarizeThreshold ?? DEFAULT_SUMMARIZE_THRESHOLD;
+    this.summaryModel = options.summaryModel ?? DEFAULT_SUMMARY_MODEL;
+    this.summaryPrompt = options.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
+    this.summarizer = options.summarizer;
+    this.includeSystemMessages = options.includeSystemMessages ?? true;
+  }
+  /** Set the summarizer function */
+  setSummarizer(fn) {
+    this.summarizer = fn;
+  }
+  async add(message) {
+    const stored = createStoredMessage(message, this.conversationId);
+    await this.store.addMessage(stored);
+    await this.checkAndSummarize();
+  }
+  async addMany(messages) {
+    for (const message of messages) {
+      const stored = createStoredMessage(message, this.conversationId);
+      await this.store.addMessage(stored);
+    }
+    await this.checkAndSummarize();
+  }
+  async getMessages() {
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    const summary = await this.getSummary();
+    if (summary) {
+      const summaryMsg = {
+        role: "system",
+        content: `Previous conversation summary:
+${summary}`
+      };
+      const filtered = messages.filter(
+        (m) => !(m.role === "system" && m.content.startsWith("Previous conversation summary:"))
+      );
+      return [summaryMsg, ...filtered];
+    }
+    return messages;
+  }
+  async getContext() {
+    const messages = await this.getMessages();
+    const summary = await this.getSummary();
+    return createContext(messages, summary);
+  }
+  async getContextWindow(maxTokens) {
+    const messages = await this.getMessages();
+    const summary = await this.getSummary();
+    const truncated = truncateMessages(messages, maxTokens, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    return createContext(truncated, summary);
+  }
+  async clear() {
+    await this.store.clear(this.conversationId);
+  }
+  async getMessageCount() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return stored.length;
+  }
+  async getTokenCount() {
+    const messages = await this.getMessages();
+    return countMessagesTokens(messages);
+  }
+  async getSummary() {
+    const metadata = await this.store.getMetadata(this.conversationId);
+    return metadata?.summary ?? null;
+  }
+  async summarize() {
+    if (!this.summarizer) {
+      throw new Error("No summarizer function provided. Set one with setSummarizer()");
+    }
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    if (messages.length === 0) {
+      return "";
+    }
+    const conversationText = formatConversationForSummary(messages);
+    const prompt = this.summaryPrompt.replace("{conversation}", conversationText);
+    const summary = await this.summarizer(messages, prompt);
+    await this.store.setMetadata(this.conversationId, { summary });
+    return summary;
+  }
+  /** Get the conversation ID */
+  getConversationId() {
+    return this.conversationId;
+  }
+  /** Switch to a different conversation */
+  setConversationId(id) {
+    this.conversationId = id;
+  }
+  extractMessages(stored) {
+    return stored.sort((a, b) => a.timestamp - b.timestamp).map((s) => s.message);
+  }
+  async checkAndSummarize() {
+    if (!this.summarizer) return;
+    const tokenCount = await this.getTokenCount();
+    if (tokenCount > this.summarizeThreshold) {
+      const stored = await this.store.getMessages(this.conversationId);
+      const messages = this.extractMessages(stored);
+      const keepCount = Math.max(4, Math.floor(messages.length / 4));
+      const toSummarize = messages.slice(0, -keepCount);
+      const toKeep = messages.slice(-keepCount);
+      if (toSummarize.length > 0) {
+        const existingSummary = await this.getSummary();
+        const messagesForSummary = existingSummary ? [{ role: "system", content: `Previous summary: ${existingSummary}` }, ...toSummarize] : toSummarize;
+        const conversationText = formatConversationForSummary(messagesForSummary);
+        const prompt = this.summaryPrompt.replace("{conversation}", conversationText);
+        const summary = await this.summarizer(messagesForSummary, prompt);
+        await this.store.clear(this.conversationId);
+        await this.store.setMetadata(this.conversationId, { summary });
+        for (const message of toKeep) {
+          const storedMsg = createStoredMessage(message, this.conversationId);
+          await this.store.addMessage(storedMsg);
+        }
+      }
+    }
+  }
+};
+
+// src/memory/summary-buffer.ts
+var DEFAULT_BUFFER_SIZE = 10;
+var DEFAULT_SUMMARIZE_THRESHOLD2 = 2e3;
+var SummaryBufferMemory = class {
+  type = "summary-buffer";
+  store;
+  conversationId;
+  bufferSize;
+  summarizeThreshold;
+  summaryPrompt;
+  summarizer;
+  includeSystemMessages;
+  constructor(options = {}) {
+    this.store = options.store ?? new InMemoryStore();
+    this.conversationId = options.conversationId ?? generateId();
+    this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE;
+    this.summarizeThreshold = options.summarizeThreshold ?? DEFAULT_SUMMARIZE_THRESHOLD2;
+    this.summaryPrompt = options.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
+    this.summarizer = options.summarizer;
+    this.includeSystemMessages = options.includeSystemMessages ?? true;
+  }
+  /** Set the summarizer function */
+  setSummarizer(fn) {
+    this.summarizer = fn;
+  }
+  async add(message) {
+    const stored = createStoredMessage(message, this.conversationId);
+    await this.store.addMessage(stored);
+    await this.checkAndSummarize();
+  }
+  async addMany(messages) {
+    for (const message of messages) {
+      const stored = createStoredMessage(message, this.conversationId);
+      await this.store.addMessage(stored);
+    }
+    await this.checkAndSummarize();
+  }
+  async getMessages() {
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    const summary = await this.getSummary();
+    const buffer = messages.slice(-this.bufferSize);
+    if (summary) {
+      const summaryMsg = {
+        role: "system",
+        content: `Previous conversation summary:
+${summary}`
+      };
+      const systemMessages = messages.slice(0, -this.bufferSize).filter((m) => m.role === "system" && !m.content.startsWith("Previous conversation summary:"));
+      return [...systemMessages, summaryMsg, ...buffer];
+    }
+    return messages;
+  }
+  async getContext() {
+    const messages = await this.getMessages();
+    const summary = await this.getSummary();
+    return createContext(messages, summary);
+  }
+  async getContextWindow(maxTokens) {
+    const messages = await this.getMessages();
+    const summary = await this.getSummary();
+    const truncated = truncateMessages(messages, maxTokens, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    return createContext(truncated, summary);
+  }
+  async clear() {
+    await this.store.clear(this.conversationId);
+  }
+  async getMessageCount() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return stored.length;
+  }
+  async getTokenCount() {
+    const messages = await this.getMessages();
+    return countMessagesTokens(messages);
+  }
+  async getSummary() {
+    const metadata = await this.store.getMetadata(this.conversationId);
+    return metadata?.summary ?? null;
+  }
+  async summarize() {
+    if (!this.summarizer) {
+      throw new Error("No summarizer function provided. Set one with setSummarizer()");
+    }
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    const toSummarize = messages.slice(0, -this.bufferSize);
+    if (toSummarize.length === 0) {
+      return "";
+    }
+    const existingSummary = await this.getSummary();
+    const messagesForSummary = existingSummary ? [{ role: "system", content: `Previous summary: ${existingSummary}` }, ...toSummarize] : toSummarize;
+    const conversationText = formatConversationForSummary(messagesForSummary);
+    const prompt = this.summaryPrompt.replace("{conversation}", conversationText);
+    const summary = await this.summarizer(messagesForSummary, prompt);
+    await this.store.setMetadata(this.conversationId, { summary });
+    return summary;
+  }
+  /** Get buffer size */
+  getBufferSize() {
+    return this.bufferSize;
+  }
+  /** Get the conversation ID */
+  getConversationId() {
+    return this.conversationId;
+  }
+  /** Switch to a different conversation */
+  setConversationId(id) {
+    this.conversationId = id;
+  }
+  extractMessages(stored) {
+    return stored.sort((a, b) => a.timestamp - b.timestamp).map((s) => s.message);
+  }
+  async checkAndSummarize() {
+    if (!this.summarizer) return;
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    if (messages.length <= this.bufferSize) return;
+    const tokenCount = await this.getTokenCount();
+    if (tokenCount > this.summarizeThreshold) {
+      const buffer = messages.slice(-this.bufferSize);
+      const toSummarize = messages.slice(0, -this.bufferSize);
+      if (toSummarize.length > 0) {
+        const existingSummary = await this.getSummary();
+        const messagesForSummary = existingSummary ? [{ role: "system", content: `Previous summary: ${existingSummary}` }, ...toSummarize] : toSummarize;
+        const conversationText = formatConversationForSummary(messagesForSummary);
+        const prompt = this.summaryPrompt.replace("{conversation}", conversationText);
+        const summary = await this.summarizer(messagesForSummary, prompt);
+        await this.store.clear(this.conversationId);
+        await this.store.setMetadata(this.conversationId, { summary });
+        for (const message of buffer) {
+          const storedMsg = createStoredMessage(message, this.conversationId);
+          await this.store.addMessage(storedMsg);
+        }
+      }
+    }
+  }
+};
+
+// src/memory/vector.ts
+var DEFAULT_TOP_K = 5;
+var DEFAULT_MIN_SCORE = 0.5;
+var VectorMemory = class {
+  type = "vector";
+  store;
+  embeddings;
+  conversationId;
+  topK;
+  minScore;
+  maxMessages;
+  maxTokens;
+  includeSystemMessages;
+  constructor(options) {
+    if (!options.embeddings) {
+      throw new Error("VectorMemory requires an embeddings provider");
+    }
+    this.store = options.store ?? new InMemoryStore();
+    this.embeddings = options.embeddings;
+    this.conversationId = options.conversationId ?? generateId();
+    this.topK = options.topK ?? DEFAULT_TOP_K;
+    this.minScore = options.minScore ?? DEFAULT_MIN_SCORE;
+    this.maxMessages = options.maxMessages;
+    this.maxTokens = options.maxTokens;
+    this.includeSystemMessages = options.includeSystemMessages ?? true;
+  }
+  async add(message) {
+    const { embedding } = await this.embeddings.embed(message.content);
+    const stored = createStoredMessage(message, this.conversationId, {
+      embedding
+    });
+    await this.store.addMessage(stored);
+  }
+  async addMany(messages) {
+    if (messages.length === 0) return;
+    const texts = messages.map((m) => m.content);
+    const { embeddings } = await this.embeddings.embedMany(texts);
+    for (let i = 0; i < messages.length; i++) {
+      const stored = createStoredMessage(messages[i], this.conversationId, {
+        embedding: embeddings[i].embedding
+      });
+      await this.store.addMessage(stored);
+    }
+  }
+  async getMessages() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return this.extractMessages(stored);
+  }
+  async getContext() {
+    const messages = await this.getMessages();
+    return createContext(messages);
+  }
+  async getContextWindow(maxTokens) {
+    const messages = await this.getMessages();
+    const truncated = truncateMessages(messages, maxTokens, {
+      keepSystemMessages: this.includeSystemMessages
+    });
+    return createContext(truncated);
+  }
+  async clear() {
+    await this.store.clear(this.conversationId);
+  }
+  async getMessageCount() {
+    const stored = await this.store.getMessages(this.conversationId);
+    return stored.length;
+  }
+  async getTokenCount() {
+    const messages = await this.getMessages();
+    return countMessagesTokens(messages);
+  }
+  async search(query, topK) {
+    const k = topK ?? this.topK;
+    const { embedding: queryEmbedding } = await this.embeddings.embed(query);
+    const stored = await this.store.getMessages(this.conversationId);
+    const results = [];
+    for (const msg of stored) {
+      if (!msg.embedding) continue;
+      const score = cosineSimilarity(queryEmbedding, msg.embedding);
+      if (score >= this.minScore) {
+        results.push({ message: msg, score });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, k);
+  }
+  /** 
+   * Get relevant context for a query.
+   * Returns messages most semantically similar to the query.
+   */
+  async getRelevantContext(query, topK) {
+    const results = await this.search(query, topK);
+    const sorted = results.sort((a, b) => a.message.timestamp - b.message.timestamp);
+    return sorted.map((r) => r.message.message);
+  }
+  /**
+   * Build context with recent messages + relevant history.
+   * Useful for including both recency and relevance.
+   */
+  async buildContext(query, options) {
+    const { recentCount = 5, relevantCount = 3 } = options ?? {};
+    const stored = await this.store.getMessages(this.conversationId);
+    const messages = this.extractMessages(stored);
+    const recent = messages.slice(-recentCount);
+    const recentIds = new Set(stored.slice(-recentCount).map((s) => s.id));
+    const relevantResults = await this.search(query, relevantCount + recentCount);
+    const relevant = relevantResults.filter((r) => !recentIds.has(r.message.id)).slice(0, relevantCount).sort((a, b) => a.message.timestamp - b.message.timestamp).map((r) => r.message.message);
+    return [...relevant, ...recent];
+  }
+  /** Get the conversation ID */
+  getConversationId() {
+    return this.conversationId;
+  }
+  /** Switch to a different conversation */
+  setConversationId(id) {
+    this.conversationId = id;
+  }
+  extractMessages(stored) {
+    return stored.sort((a, b) => a.timestamp - b.timestamp).map((s) => s.message);
+  }
+};
+
+// src/memory/stores/local-storage.ts
+var MESSAGES_PREFIX = "binario:memory:messages:";
+var METADATA_PREFIX = "binario:memory:metadata:";
+var LocalStorageStore = class {
+  prefix;
+  constructor(prefix = "") {
+    this.prefix = prefix;
+  }
+  getMessagesKey(conversationId) {
+    return `${MESSAGES_PREFIX}${this.prefix}${conversationId}`;
+  }
+  getMetadataKey(conversationId) {
+    return `${METADATA_PREFIX}${this.prefix}${conversationId}`;
+  }
+  getStorage() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+    return null;
+  }
+  async getMessages(conversationId) {
+    const storage = this.getStorage();
+    if (!storage) return [];
+    try {
+      const data = storage.getItem(this.getMessagesKey(conversationId));
+      return data ? JSON.parse(data) : [];
+    } catch {
+      return [];
+    }
+  }
+  async addMessage(message) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const messages = await this.getMessages(message.conversationId);
+    messages.push(message);
+    try {
+      storage.setItem(
+        this.getMessagesKey(message.conversationId),
+        JSON.stringify(messages)
+      );
+    } catch (e) {
+      if (e instanceof Error && e.name === "QuotaExceededError") {
+        try {
+          const trimmed = messages.slice(-Math.floor(messages.length / 2));
+          storage.setItem(
+            this.getMessagesKey(message.conversationId),
+            JSON.stringify(trimmed)
+          );
+        } catch {
+        }
+      }
+    }
+  }
+  async updateMessage(id, updates) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const keys = Object.keys(storage).filter((k) => k.startsWith(MESSAGES_PREFIX + this.prefix));
+    for (const key of keys) {
+      try {
+        const data = storage.getItem(key);
+        if (!data) continue;
+        const messages = JSON.parse(data);
+        const index = messages.findIndex((m) => m.id === id);
+        if (index !== -1) {
+          messages[index] = { ...messages[index], ...updates };
+          storage.setItem(key, JSON.stringify(messages));
+          return;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  async deleteMessage(id) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const keys = Object.keys(storage).filter((k) => k.startsWith(MESSAGES_PREFIX + this.prefix));
+    for (const key of keys) {
+      try {
+        const data = storage.getItem(key);
+        if (!data) continue;
+        const messages = JSON.parse(data);
+        const filtered = messages.filter((m) => m.id !== id);
+        if (filtered.length !== messages.length) {
+          storage.setItem(key, JSON.stringify(filtered));
+          return;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  async clear(conversationId) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    storage.removeItem(this.getMessagesKey(conversationId));
+    storage.removeItem(this.getMetadataKey(conversationId));
+  }
+  async getMetadata(conversationId) {
+    const storage = this.getStorage();
+    if (!storage) return null;
+    try {
+      const data = storage.getItem(this.getMetadataKey(conversationId));
+      return data ? JSON.parse(data) : null;
+    } catch {
+      return null;
+    }
+  }
+  async setMetadata(conversationId, metadata) {
+    const storage = this.getStorage();
+    if (!storage) return;
+    storage.setItem(this.getMetadataKey(conversationId), JSON.stringify(metadata));
+  }
+  /** Clear all binario memory data */
+  clearAll() {
+    const storage = this.getStorage();
+    if (!storage) return;
+    const keysToRemove = Object.keys(storage).filter(
+      (k) => k.startsWith(MESSAGES_PREFIX + this.prefix) || k.startsWith(METADATA_PREFIX + this.prefix)
+    );
+    keysToRemove.forEach((key) => storage.removeItem(key));
+  }
+  /** Get all conversation IDs */
+  getConversationIds() {
+    const storage = this.getStorage();
+    if (!storage) return [];
+    const prefix = MESSAGES_PREFIX + this.prefix;
+    return Object.keys(storage).filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
+  }
+};
+
+// src/embeddings/cloudflare.ts
+var CLOUDFLARE_EMBEDDING_MODELS = {
+  "bge-base-en": "@cf/baai/bge-base-en-v1.5",
+  "bge-large-en": "@cf/baai/bge-large-en-v1.5",
+  "bge-small-en": "@cf/baai/bge-small-en-v1.5"
+};
+var DEFAULT_MODEL = CLOUDFLARE_EMBEDDING_MODELS["bge-base-en"];
+var CloudflareEmbeddings = class {
+  name = "cloudflare";
+  binding;
+  accountId;
+  apiKey;
+  model;
+  constructor(config = {}) {
+    this.binding = config.binding;
+    this.accountId = config.accountId;
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL;
+    if (this.model in CLOUDFLARE_EMBEDDING_MODELS) {
+      this.model = CLOUDFLARE_EMBEDDING_MODELS[this.model];
+    }
+  }
+  async embed(text) {
+    const result = await this.embedMany([text]);
+    return result.embeddings[0];
+  }
+  async embedMany(texts) {
+    if (texts.length === 0) {
+      return {
+        embeddings: [],
+        model: this.model,
+        usage: { promptTokens: 0, totalTokens: 0 }
+      };
+    }
+    let embeddings;
+    if (this.binding) {
+      const response = await this.binding.run(this.model, { text: texts });
+      embeddings = response.data;
+    } else if (this.accountId && this.apiKey) {
+      embeddings = await this.embedViaRest(texts);
+    } else {
+      throw new Error("CloudflareEmbeddings requires either a binding or accountId + apiKey");
+    }
+    const promptTokens = texts.reduce((sum, t) => sum + countTokens(t), 0);
+    return {
+      embeddings: texts.map((text, i) => ({
+        text,
+        embedding: embeddings[i],
+        tokenCount: countTokens(text)
+      })),
+      model: this.model,
+      usage: {
+        promptTokens,
+        totalTokens: promptTokens
+      }
+    };
+  }
+  async embedViaRest(texts) {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/ai/run/${this.model}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text: texts })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Cloudflare embeddings failed: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return data.result.data;
+  }
+  /** Get the current model */
+  getModel() {
+    return this.model;
+  }
+  /** Set a new model */
+  setModel(model) {
+    this.model = model in CLOUDFLARE_EMBEDDING_MODELS ? CLOUDFLARE_EMBEDDING_MODELS[model] : model;
+  }
+};
+
+// src/hooks.ts
+function useBinarioChat(binario, options = {}) {
+  const [messages, setMessages] = useState(options.initialMessages || []);
+  const [input, setInput] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [lastResponse, setLastResponse] = useState(null);
+  const abortControllerRef = useRef(null);
+  const stop = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    setIsLoading(false);
+  }, []);
+  const append = useCallback(
+    async (message) => {
+      setIsLoading(true);
+      setError(null);
+      abortControllerRef.current = new AbortController();
+      const newMessages = [...messages, message];
+      setMessages(newMessages);
+      try {
+        const response = await binario.chat(newMessages, options);
+        const assistantMessage = {
+          role: "assistant",
+          content: response.content,
+          tool_calls: response.toolCalls
+        };
+        setMessages([...newMessages, assistantMessage]);
+        setLastResponse(response);
+        options.onFinish?.(response);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [messages, binario, options]
+  );
+  const reload = useCallback(async () => {
+    if (messages.length === 0) return;
+    const lastUserMessageIndex = messages.map((m) => m.role).lastIndexOf("user");
+    if (lastUserMessageIndex === -1) return;
+    const messagesToReload = messages.slice(0, lastUserMessageIndex + 1);
+    setMessages(messagesToReload);
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await binario.chat(messagesToReload, options);
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content,
+        tool_calls: response.toolCalls
+      };
+      setMessages([...messagesToReload, assistantMessage]);
+      setLastResponse(response);
+      options.onFinish?.(response);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      options.onError?.(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [messages, binario, options]);
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  return {
+    messages,
+    input,
+    setInput,
+    isLoading,
+    error,
+    append,
+    reload,
+    stop,
+    setMessages,
+    lastResponse
+  };
+}
+function useBinarioStream(binario, options = {}) {
+  const [messages, setMessages] = useState(options.initialMessages || []);
+  const [input, setInput] = useState("");
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [error, setError] = useState(null);
+  const [streamingContent, setStreamingContent] = useState("");
+  const abortRef = useRef(false);
+  const stop = useCallback(() => {
+    abortRef.current = true;
+    setIsStreaming(false);
+  }, []);
+  const send = useCallback(
+    async (content) => {
+      setIsStreaming(true);
+      setError(null);
+      setStreamingContent("");
+      abortRef.current = false;
+      const userMessage = { role: "user", content };
+      const newMessages = [...messages, userMessage];
+      setMessages(newMessages);
+      let fullContent = "";
+      const callbacks = {
+        onToken: (token) => {
+          if (abortRef.current) return;
+          fullContent += token;
+          setStreamingContent(fullContent);
+          options.onToken?.(token);
+        },
+        onComplete: (response) => {
+          const assistantMessage = { role: "assistant", content: fullContent };
+          setMessages([...newMessages, assistantMessage]);
+          setStreamingContent("");
+          options.onFinish?.(response);
+        },
+        onError: (err) => {
+          setError(err);
+          options.onError?.(err);
+        }
+      };
+      try {
+        const stream = binario.streamChat(newMessages, options, callbacks);
+        for await (const _ of stream) {
+          if (abortRef.current) break;
+        }
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+      } finally {
+        setIsStreaming(false);
+      }
+    },
+    [messages, binario, options]
+  );
+  return {
+    messages,
+    input,
+    setInput,
+    isStreaming,
+    error,
+    streamingContent,
+    send,
+    stop,
+    setMessages
+  };
+}
+function useBinarioCompletion(binario, options = {}) {
+  const [completion, setCompletion] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const complete = useCallback(
+    async (prompt, systemPrompt) => {
+      setIsLoading(true);
+      setError(null);
+      setCompletion("");
+      const messages = [];
+      if (systemPrompt) {
+        messages.push({ role: "system", content: systemPrompt });
+      }
+      messages.push({ role: "user", content: prompt });
+      try {
+        const response = await binario.chat(messages, options);
+        setCompletion(response.content);
+        options.onFinish?.(response);
+        return response.content;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [binario, options]
+  );
+  return {
+    completion,
+    isLoading,
+    error,
+    complete
+  };
+}
+function useBinarioAgent(agent, options = {}) {
+  const [output, setOutput] = useState("");
+  const [isRunning, setIsRunning] = useState(false);
+  const [error, setError] = useState(null);
+  const [steps, setSteps] = useState([]);
+  const abortRef = useRef(false);
+  const stop = useCallback(() => {
+    abortRef.current = true;
+    setIsRunning(false);
+  }, []);
+  const run = useCallback(
+    async (input, context) => {
+      setIsRunning(true);
+      setError(null);
+      setOutput("");
+      setSteps([]);
+      abortRef.current = false;
+      try {
+        const agentWithContext = context ? agent.withContext(context) : agent;
+        const result = await agentWithContext.run(input, {
+          maxSteps: options.maxSteps,
+          onStep: (step) => {
+            if (abortRef.current) return;
+            setSteps((prev) => [...prev, step]);
+            options.onStep?.(step);
+          }
+        });
+        setOutput(result.output);
+        return result.output;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+        return null;
+      } finally {
+        setIsRunning(false);
+      }
+    },
+    [agent, options]
+  );
+  const runStructured = useCallback(
+    async (input, schema, context) => {
+      setIsRunning(true);
+      setError(null);
+      setOutput("");
+      setSteps([]);
+      abortRef.current = false;
+      try {
+        const agentWithContext = context ? agent.withContext(context) : agent;
+        const result = await agentWithContext.runStructured(input, schema, {
+          maxSteps: options.maxSteps
+        });
+        setOutput(JSON.stringify(result.output, null, 2));
+        return result.output;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+        return null;
+      } finally {
+        setIsRunning(false);
+      }
+    },
+    [agent, options]
+  );
+  return {
+    output,
+    isRunning,
+    error,
+    steps,
+    run,
+    runStructured,
+    stop
+  };
+}
+function useBinarioStructured(binario, options) {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const generate = useCallback(
+    async (prompt, systemPrompt) => {
+      setIsLoading(true);
+      setError(null);
+      setData(null);
+      const messages = [];
+      if (systemPrompt) {
+        messages.push({ role: "system", content: systemPrompt });
+      }
+      messages.push({ role: "user", content: prompt });
+      try {
+        const response = await binario.chat(messages, {
+          ...options,
+          outputSchema: options.schema
+        });
+        const parsedData = response.data;
+        setData(parsedData);
+        options.onFinish?.(parsedData);
+        return parsedData;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [binario, options]
+  );
+  return {
+    data,
+    isLoading,
+    error,
+    generate
+  };
+}
+function useBinarioTools(binario, options) {
+  const [messages, setMessages] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [error, setError] = useState(null);
+  const send = useCallback(
+    async (content) => {
+      setIsProcessing(true);
+      setError(null);
+      const userMessage = { role: "user", content };
+      const newMessages = [...messages, userMessage];
+      setMessages(newMessages);
+      try {
+        const apiTools = options.tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: zodToJsonSchema(tool.parameters)
+          }
+        }));
+        let currentMessages = newMessages;
+        let continueLoop = true;
+        while (continueLoop) {
+          const response = await binario.chat(currentMessages, {
+            provider: options.provider,
+            model: options.model,
+            tools: apiTools
+          });
+          if (response.toolCalls && response.toolCalls.length > 0) {
+            const toolResults = [];
+            for (const toolCall of response.toolCalls) {
+              const tool = options.tools.find((t) => t.name === toolCall.function.name);
+              if (tool) {
+                const args = JSON.parse(toolCall.function.arguments);
+                options.onToolCall?.(toolCall.function.name, args);
+                const result = await tool.execute(args);
+                options.onToolResult?.(toolCall.function.name, result);
+                toolResults.push({
+                  role: "tool",
+                  content: JSON.stringify(result),
+                  tool_call_id: toolCall.id
+                });
+              }
+            }
+            currentMessages = [
+              ...currentMessages,
+              { role: "assistant", content: response.content, tool_calls: response.toolCalls },
+              ...toolResults
+            ];
+          } else {
+            const assistantMessage = {
+              role: "assistant",
+              content: response.content
+            };
+            currentMessages = [...currentMessages, assistantMessage];
+            continueLoop = false;
+          }
+        }
+        setMessages(currentMessages);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        options.onError?.(error2);
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [messages, binario, options]
+  );
+  return {
+    messages,
+    isProcessing,
+    error,
+    send,
+    setMessages
+  };
+}
+function useBinarioMemory(options = {}) {
+  const {
+    type = "buffer",
+    conversationId: initialConversationId,
+    store: storeOption = "memory",
+    storagePrefix = "",
+    maxMessages = 50,
+    maxTokens = 4e3,
+    bufferSize = 10,
+    summarizer,
+    embeddings,
+    topK = 5,
+    minScore = 0.5
+  } = options;
+  const store = useRef(
+    typeof storeOption === "string" ? storeOption === "localStorage" ? new LocalStorageStore(storagePrefix) : new InMemoryStore() : storeOption
+  );
+  const memory = useRef(null);
+  const [memoryState, setMemoryState] = useState(null);
+  const [conversationId, setConversationId] = useState(
+    initialConversationId || `conv-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`
+  );
+  const [messages, setMessages] = useState([]);
+  const [context, setContext] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const isInitialLoad = useRef(true);
+  const createMemory = useCallback(() => {
+    const memoryOptions = {
+      store: store.current,
+      conversationId,
+      maxMessages,
+      maxTokens
+    };
+    let mem;
+    switch (type) {
+      case "summary": {
+        const summaryMem = new SummaryMemory({ ...memoryOptions, summarizer });
+        if (summarizer) summaryMem.setSummarizer(summarizer);
+        mem = summaryMem;
+        break;
+      }
+      case "summary-buffer": {
+        const sbMem = new SummaryBufferMemory({ ...memoryOptions, bufferSize, summarizer });
+        if (summarizer) sbMem.setSummarizer(summarizer);
+        mem = sbMem;
+        break;
+      }
+      case "vector":
+        if (!embeddings) {
+          throw new Error("VectorMemory requires an embeddings provider");
+        }
+        mem = new VectorMemory({ ...memoryOptions, embeddings, topK, minScore });
+        break;
+      default:
+        mem = new BufferMemory(memoryOptions);
+    }
+    return mem;
+  }, [type, conversationId, maxMessages, maxTokens, summarizer, bufferSize, embeddings, topK, minScore]);
+  if (!memory.current) {
+    memory.current = createMemory();
+    setMemoryState(memory.current);
+  }
+  useEffect(() => {
+    memory.current = createMemory();
+    setMemoryState(memory.current);
+    loadMessages(isInitialLoad.current);
+    isInitialLoad.current = false;
+  }, [type, conversationId]);
+  const loadMessages = useCallback(async (skipLoadingState = false) => {
+    if (!memory.current) return;
+    if (!skipLoadingState) {
+      setIsLoading(true);
+    }
+    try {
+      const msgs = await memory.current.getMessages();
+      const ctx = await memory.current.getContext();
+      setMessages(msgs);
+      setContext(ctx);
+    } catch (error) {
+      console.error("Failed to load memory:", error);
+    } finally {
+      if (!skipLoadingState) {
+        setIsLoading(false);
+      }
+    }
+  }, []);
+  const addMessage = useCallback(async (message) => {
+    if (!memory.current) return;
+    await memory.current.add(message);
+    await loadMessages();
+  }, [loadMessages]);
+  const addMessages = useCallback(async (msgs) => {
+    if (!memory.current) return;
+    await memory.current.addMany(msgs);
+    await loadMessages();
+  }, [loadMessages]);
+  const clear = useCallback(async () => {
+    if (!memory.current) return;
+    await memory.current.clear();
+    setMessages([]);
+    setContext(null);
+  }, []);
+  const refresh = useCallback(async () => {
+    await loadMessages();
+  }, [loadMessages]);
+  const getContextWindow = useCallback(async (maxTkns) => {
+    if (!memory.current) {
+      return { messages: [], tokenCount: 0, messageCount: 0 };
+    }
+    return memory.current.getContextWindow(maxTkns);
+  }, []);
+  const switchConversation = useCallback((id) => {
+    setConversationId(id);
+  }, []);
+  return {
+    memory: memoryState,
+    messages,
+    context,
+    isLoading,
+    addMessage,
+    addMessages,
+    clear,
+    refresh,
+    getContextWindow,
+    conversationId,
+    switchConversation
+  };
+}
+function useBinarioChatWithMemory(binario, options = {}) {
+  const {
+    memory: memoryOptions = {},
+    autoSave = true,
+    contextWindowSize = 4e3,
+    ...chatOptions
+  } = options;
+  const memoryHook = useBinarioMemory(memoryOptions);
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [lastResponse, setLastResponse] = useState(null);
+  const abortControllerRef = useRef(null);
+  useEffect(() => {
+    if (memoryHook.messages.length > 0 && messages.length === 0) {
+      setMessages(memoryHook.messages);
+    }
+  }, [memoryHook.messages]);
+  const stop = useCallback(() => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    setIsLoading(false);
+  }, []);
+  const append = useCallback(
+    async (message) => {
+      setIsLoading(true);
+      setError(null);
+      abortControllerRef.current = new AbortController();
+      const newMessages = [...messages, message];
+      setMessages(newMessages);
+      if (autoSave) {
+        await memoryHook.addMessage(message);
+      }
+      try {
+        const contextWindow = await memoryHook.getContextWindow(contextWindowSize);
+        const contextMessages = contextWindow.messages.length > 0 ? contextWindow.messages : newMessages;
+        const response = await binario.chat(contextMessages, chatOptions);
+        const assistantMessage = {
+          role: "assistant",
+          content: response.content,
+          tool_calls: response.toolCalls
+        };
+        const updatedMessages = [...newMessages, assistantMessage];
+        setMessages(updatedMessages);
+        setLastResponse(response);
+        if (autoSave) {
+          await memoryHook.addMessage(assistantMessage);
+        }
+        chatOptions.onFinish?.(response);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        chatOptions.onError?.(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [messages, binario, chatOptions, autoSave, memoryHook, contextWindowSize]
+  );
+  const reload = useCallback(async () => {
+    if (messages.length === 0) return;
+    const lastUserMessageIndex = messages.map((m) => m.role).lastIndexOf("user");
+    if (lastUserMessageIndex === -1) return;
+    const messagesToReload = messages.slice(0, lastUserMessageIndex + 1);
+    setMessages(messagesToReload);
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await binario.chat(messagesToReload, chatOptions);
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content,
+        tool_calls: response.toolCalls
+      };
+      setMessages([...messagesToReload, assistantMessage]);
+      setLastResponse(response);
+      chatOptions.onFinish?.(response);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      chatOptions.onError?.(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [messages, binario, chatOptions]);
+  const loadConversation = useCallback(async (conversationId) => {
+    if (conversationId) {
+      memoryHook.switchConversation(conversationId);
+    }
+    await memoryHook.refresh();
+    setMessages(memoryHook.messages);
+  }, [memoryHook]);
+  const saveConversation = useCallback(async () => {
+    await memoryHook.clear();
+    await memoryHook.addMessages(messages);
+  }, [memoryHook, messages]);
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  return {
+    messages,
+    input,
+    setInput,
+    isLoading,
+    error,
+    append,
+    reload,
+    stop,
+    setMessages,
+    lastResponse,
+    memory: memoryHook,
+    loadConversation,
+    saveConversation
+  };
+}
+function useBinarioEmbed(options = {}) {
+  const {
+    provider: providerType = "cloudflare",
+    customProvider,
+    model,
+    accountId,
+    apiKey,
+    cache = true,
+    onStart,
+    onComplete,
+    onError
+  } = options;
+  const [result, setResult] = useState(null);
+  const [batchResult, setBatchResult] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const cacheRef = useRef(/* @__PURE__ */ new Map());
+  const providerRef = useRef(null);
+  useEffect(() => {
+    if (customProvider) {
+      providerRef.current = customProvider;
+    } else if (providerType === "cloudflare") {
+      providerRef.current = new CloudflareEmbeddings({
+        model,
+        accountId,
+        apiKey
+      });
+    }
+  }, [providerType, customProvider, model, accountId, apiKey]);
+  const embed = useCallback(async (text) => {
+    if (!providerRef.current) {
+      const err = new Error("Embeddings provider not initialized");
+      setError(err);
+      onError?.(err);
+      return null;
+    }
+    if (cache && cacheRef.current.has(text)) {
+      const cached = {
+        text,
+        embedding: cacheRef.current.get(text)
+      };
+      setResult(cached);
+      return cached;
+    }
+    setIsLoading(true);
+    setError(null);
+    onStart?.();
+    try {
+      const embeddingResult = await providerRef.current.embed(text);
+      if (cache) {
+        cacheRef.current.set(text, embeddingResult.embedding);
+      }
+      setResult(embeddingResult);
+      onComplete?.(embeddingResult);
+      return embeddingResult;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      onError?.(error2);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [cache, onStart, onComplete, onError]);
+  const embedMany = useCallback(async (texts) => {
+    if (!providerRef.current) {
+      const err = new Error("Embeddings provider not initialized");
+      setError(err);
+      onError?.(err);
+      return null;
+    }
+    if (texts.length === 0) {
+      return { embeddings: [], model: "", usage: { promptTokens: 0, totalTokens: 0 } };
+    }
+    const uncached = [];
+    const cachedResults = /* @__PURE__ */ new Map();
+    if (cache) {
+      for (const text of texts) {
+        if (cacheRef.current.has(text)) {
+          cachedResults.set(text, cacheRef.current.get(text));
+        } else {
+          uncached.push(text);
+        }
+      }
+    } else {
+      uncached.push(...texts);
+    }
+    setIsLoading(true);
+    setError(null);
+    onStart?.();
+    try {
+      let newEmbeddings = {
+        embeddings: [],
+        model: "",
+        usage: { promptTokens: 0, totalTokens: 0 }
+      };
+      if (uncached.length > 0) {
+        newEmbeddings = await providerRef.current.embedMany(uncached);
+        if (cache) {
+          for (const emb of newEmbeddings.embeddings) {
+            cacheRef.current.set(emb.text, emb.embedding);
+          }
+        }
+      }
+      const allEmbeddings = texts.map((text) => {
+        if (cachedResults.has(text)) {
+          return { text, embedding: cachedResults.get(text) };
+        }
+        const found = newEmbeddings.embeddings.find((e) => e.text === text);
+        return found || { text, embedding: [] };
+      });
+      const batchResult2 = {
+        embeddings: allEmbeddings,
+        model: newEmbeddings.model,
+        usage: newEmbeddings.usage
+      };
+      setBatchResult(batchResult2);
+      onComplete?.(batchResult2);
+      return batchResult2;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      onError?.(error2);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [cache, onStart, onComplete, onError]);
+  const similarity = useCallback(async (text1, text2) => {
+    const results = await embedMany([text1, text2]);
+    if (!results || results.embeddings.length < 2) {
+      return null;
+    }
+    const [emb1, emb2] = results.embeddings;
+    return cosineSimilarity(emb1.embedding, emb2.embedding);
+  }, [embedMany]);
+  const findSimilar = useCallback(async (query, candidates, topK = 5) => {
+    if (candidates.length === 0) return [];
+    const allTexts = [query, ...candidates];
+    const results = await embedMany(allTexts);
+    if (!results || results.embeddings.length === 0) {
+      return null;
+    }
+    const queryEmbedding = results.embeddings[0].embedding;
+    const candidateEmbeddings = results.embeddings.slice(1);
+    const similarities = candidateEmbeddings.map((emb, i) => ({
+      text: candidates[i],
+      score: cosineSimilarity(queryEmbedding, emb.embedding)
+    }));
+    return similarities.sort((a, b) => b.score - a.score).slice(0, topK);
+  }, [embedMany]);
+  const clearCache = useCallback(() => {
+    cacheRef.current.clear();
+  }, []);
+  const getCached = useCallback((text) => {
+    return cacheRef.current.get(text) ?? null;
+  }, []);
+  return {
+    embed,
+    embedMany,
+    similarity,
+    findSimilar,
+    result,
+    batchResult,
+    isLoading,
+    error,
+    clearCache,
+    getCached
+  };
+}
+function useBinarioSemanticSearch(options = {}) {
+  const { minScore = 0.5, maxResults = 10, ...embedOptions } = options;
+  const { embedMany, clearCache, error: embedError } = useBinarioEmbed(embedOptions);
+  const indexRef = useRef(/* @__PURE__ */ new Map());
+  const [documentCount, setDocumentCount] = useState(0);
+  const [isIndexing, setIsIndexing] = useState(false);
+  const [isSearching, setIsSearching] = useState(false);
+  const [error, setError] = useState(null);
+  const addDocuments = useCallback(async (documents) => {
+    if (documents.length === 0) return;
+    setIsIndexing(true);
+    setError(null);
+    try {
+      const texts = documents.map((d) => d.text);
+      let embeddings;
+      try {
+        embeddings = await embedMany(texts);
+      } catch (err) {
+        setError(err);
+        setIsIndexing(false);
+        return;
+      }
+      if (!embeddings) {
+        setError(embedError || new Error("Failed to generate embeddings"));
+        setIsIndexing(false);
+        return;
+      }
+      for (let i = 0; i < documents.length; i++) {
+        indexRef.current.set(documents[i].id, {
+          document: documents[i],
+          embedding: embeddings.embeddings[i].embedding
+        });
+      }
+      setDocumentCount(indexRef.current.size);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsIndexing(false);
+    }
+  }, [embedMany]);
+  const search = useCallback(async (query) => {
+    if (indexRef.current.size === 0) return [];
+    setIsSearching(true);
+    setError(null);
+    try {
+      const queryEmbeddings = await embedMany([query]);
+      if (!queryEmbeddings || queryEmbeddings.embeddings.length === 0) {
+        throw new Error("Failed to generate query embedding");
+      }
+      const queryEmbedding = queryEmbeddings.embeddings[0].embedding;
+      const results = [];
+      for (const { document, embedding } of indexRef.current.values()) {
+        const score = cosineSimilarity(queryEmbedding, embedding);
+        if (score >= minScore) {
+          results.push({ document, score });
+        }
+      }
+      return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+    } catch (err) {
+      setError(err);
+      return [];
+    } finally {
+      setIsSearching(false);
+    }
+  }, [embedMany, minScore, maxResults]);
+  const removeDocuments = useCallback((ids) => {
+    for (const id of ids) {
+      indexRef.current.delete(id);
+    }
+    setDocumentCount(indexRef.current.size);
+  }, []);
+  const clear = useCallback(() => {
+    indexRef.current.clear();
+    clearCache();
+    setDocumentCount(0);
+  }, [clearCache]);
+  return {
+    addDocuments,
+    search,
+    removeDocuments,
+    clear,
+    documentCount,
+    isIndexing,
+    isSearching,
+    error
+  };
+}
+
+export { useBinarioAgent, useBinarioChat, useBinarioChatWithMemory, useBinarioCompletion, useBinarioEmbed, useBinarioMemory, useBinarioSemanticSearch, useBinarioStream, useBinarioStructured, useBinarioTools };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map