binario 0.1.0

package/dist/memory.js

@@ -0,0 +1,931 @@
+// 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 formatContextWithSummary(recentMessages, summary) {
+  if (!summary) {
+    return recentMessages;
+  }
+  const summaryMessage = {
+    role: "system",
+    content: `Previous conversation summary:
+${summary}`
+  };
+  const filtered = recentMessages.filter(
+    (m) => !(m.role === "system" && m.content.startsWith("Previous conversation summary:"))
+  );
+  const firstNonSystemIdx = filtered.findIndex((m) => m.role !== "system");
+  const insertIdx = firstNonSystemIdx === -1 ? filtered.length : firstNonSystemIdx;
+  return [
+    ...filtered.slice(0, insertIdx),
+    summaryMessage,
+    ...filtered.slice(insertIdx)
+  ];
+}
+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());
+  }
+};
+function createInMemoryStore() {
+  return new InMemoryStore();
+}
+
+// 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);
+      }
+    }
+  }
+};
+function createBufferMemory(options = {}) {
+  return new BufferMemory(options);
+}
+
+// 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);
+        }
+      }
+    }
+  }
+};
+function createSummaryMemory(options = {}) {
+  return new SummaryMemory(options);
+}
+
+// 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);
+        }
+      }
+    }
+  }
+};
+function createSummaryBufferMemory(options = {}) {
+  return new SummaryBufferMemory(options);
+}
+
+// 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);
+  }
+};
+function createVectorMemory(options) {
+  return new VectorMemory(options);
+}
+
+// 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));
+  }
+};
+function createLocalStorageStore(prefix = "") {
+  return new LocalStorageStore(prefix);
+}
+
+// src/memory/stores/cloudflare-kv.ts
+var MESSAGES_PREFIX2 = "messages:";
+var METADATA_PREFIX2 = "metadata:";
+var CloudflareKVStore = class {
+  kv;
+  ttl;
+  /**
+   * @param kv - Cloudflare KV namespace binding
+   * @param ttl - Optional TTL in seconds for automatic expiration
+   */
+  constructor(kv, ttl) {
+    this.kv = kv;
+    this.ttl = ttl;
+  }
+  getMessagesKey(conversationId) {
+    return `${MESSAGES_PREFIX2}${conversationId}`;
+  }
+  getMetadataKey(conversationId) {
+    return `${METADATA_PREFIX2}${conversationId}`;
+  }
+  async getMessages(conversationId) {
+    try {
+      const data = await this.kv.get(this.getMessagesKey(conversationId), { type: "json" });
+      return data ?? [];
+    } catch {
+      return [];
+    }
+  }
+  async addMessage(message) {
+    const messages = await this.getMessages(message.conversationId);
+    messages.push(message);
+    await this.kv.put(
+      this.getMessagesKey(message.conversationId),
+      JSON.stringify(messages),
+      this.ttl ? { expirationTtl: this.ttl } : void 0
+    );
+  }
+  async updateMessage(id, updates) {
+    const { keys } = await this.kv.list({ prefix: MESSAGES_PREFIX2 });
+    for (const { name: key } of keys) {
+      const conversationId = key.slice(MESSAGES_PREFIX2.length);
+      const messages = await this.getMessages(conversationId);
+      const index = messages.findIndex((m) => m.id === id);
+      if (index !== -1) {
+        messages[index] = { ...messages[index], ...updates };
+        await this.kv.put(
+          key,
+          JSON.stringify(messages),
+          this.ttl ? { expirationTtl: this.ttl } : void 0
+        );
+        return;
+      }
+    }
+  }
+  async deleteMessage(id) {
+    const { keys } = await this.kv.list({ prefix: MESSAGES_PREFIX2 });
+    for (const { name: key } of keys) {
+      const conversationId = key.slice(MESSAGES_PREFIX2.length);
+      const messages = await this.getMessages(conversationId);
+      const filtered = messages.filter((m) => m.id !== id);
+      if (filtered.length !== messages.length) {
+        await this.kv.put(
+          key,
+          JSON.stringify(filtered),
+          this.ttl ? { expirationTtl: this.ttl } : void 0
+        );
+        return;
+      }
+    }
+  }
+  async clear(conversationId) {
+    await Promise.all([
+      this.kv.delete(this.getMessagesKey(conversationId)),
+      this.kv.delete(this.getMetadataKey(conversationId))
+    ]);
+  }
+  async getMetadata(conversationId) {
+    try {
+      const data = await this.kv.get(this.getMetadataKey(conversationId), { type: "json" });
+      return data ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async setMetadata(conversationId, metadata) {
+    await this.kv.put(
+      this.getMetadataKey(conversationId),
+      JSON.stringify(metadata),
+      this.ttl ? { expirationTtl: this.ttl } : void 0
+    );
+  }
+  /** Clear all binario memory data in this KV namespace */
+  async clearAll() {
+    const { keys } = await this.kv.list();
+    await Promise.all(keys.map(({ name }) => this.kv.delete(name)));
+  }
+  /** Get all conversation IDs */
+  async getConversationIds() {
+    const { keys } = await this.kv.list({ prefix: MESSAGES_PREFIX2 });
+    return keys.map(({ name }) => name.slice(MESSAGES_PREFIX2.length));
+  }
+};
+function createCloudflareKVStore(kv, ttl) {
+  return new CloudflareKVStore(kv, ttl);
+}
+
+export { BufferMemory, CloudflareKVStore, DEFAULT_SUMMARY_PROMPT, InMemoryStore, LocalStorageStore, SummaryBufferMemory, SummaryMemory, VectorMemory, cosineSimilarity, countMessageTokens, countMessagesTokens, countTokens, createBufferMemory, createCloudflareKVStore, createInMemoryStore, createLocalStorageStore, createStoredMessage, createSummaryBufferMemory, createSummaryMemory, createVectorMemory, formatContextWithSummary, formatConversationForSummary, generateId, truncateMessages, truncateMessagesByCount };
+//# sourceMappingURL=memory.js.map
+//# sourceMappingURL=memory.js.map