@memstack/core 0.2.0

package/dist/index.js

@@ -0,0 +1,1974 @@
+import { mkdir, readFile, writeFile, readdir } from 'fs/promises';
+import { join } from 'path';
+
+// src/errors.ts
+var MemStackError = class extends Error {
+  code;
+  retryable;
+  details;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "MemStackError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.details = options.details;
+  }
+};
+function notFound(entity, id) {
+  return new MemStackError("NOT_FOUND", `${entity} not found: ${id}`, {
+    retryable: false,
+    details: { entity, id }
+  });
+}
+function validationError(message, details) {
+  return new MemStackError("VALIDATION_ERROR", message, { details });
+}
+function storageError(message, cause) {
+  return new MemStackError("STORAGE_ERROR", message, {
+    retryable: true,
+    details: { cause: cause instanceof Error ? cause.message : String(cause) }
+  });
+}
+function configError(message) {
+  return new MemStackError("CONFIG_ERROR", message, { retryable: false });
+}
+
+// src/memory/Summarizer.ts
+var Summarizer = class {
+  llm;
+  defaultPrompt;
+  constructor(llm, defaultPrompt) {
+    this.llm = llm;
+    this.defaultPrompt = defaultPrompt ?? "You are a memory summarizer. Condense the following list of memories into a single, concise summary paragraph that captures the key events, emotional tone, and important details. Write in third person past tense.";
+  }
+  async summarize(memories, options = {}, promptOverride) {
+    if (memories.length === 0) {
+      throw new MemStackError("VALIDATION_ERROR", "No memories to summarize");
+    }
+    const sorted = [...memories].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    const memoryTexts = sorted.map((m) => `[${m.createdAt.toISOString()}] ${m.content}`);
+    const system = promptOverride ?? this.defaultPrompt;
+    const user = memoryTexts.join("\n\n");
+    try {
+      const response = await this.llm.complete({ system, user });
+      return {
+        summaryContent: response.text.trim(),
+        tokenCount: response.tokens.total
+      };
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError(
+        "LLM_ERROR",
+        `Summarization failed: ${err instanceof Error ? err.message : String(err)}`,
+        { retryable: true, details: { cause: err instanceof Error ? err.message : String(err) } }
+      );
+    }
+  }
+};
+
+// src/memory/Pruner.ts
+var Pruner = class {
+  /** Returns memories to KEEP after applying the strategy. */
+  execute(memories, strategy) {
+    switch (strategy.type) {
+      case "byAge":
+        return this.keepByAge(memories, strategy);
+      case "byImportance":
+        return this.keepByImportance(memories, strategy);
+      case "byCount":
+        return this.keepByCount(memories, strategy);
+      case "byType":
+        return this.removeByType(memories, strategy);
+      case "custom":
+        return this.removeCustom(memories, strategy);
+      default:
+        return memories;
+    }
+  }
+  dryRun(memories, strategy) {
+    return this.execute(memories, strategy);
+  }
+  keepByAge(memories, strategy) {
+    if (!strategy.maxAge) return memories;
+    const cutoff = Date.now() - strategy.maxAge;
+    return memories.filter((m) => m.createdAt.getTime() >= cutoff);
+  }
+  keepByImportance(memories, strategy) {
+    const threshold = strategy.minImportance ?? 0.5;
+    return memories.filter((m) => m.importance >= threshold);
+  }
+  keepByCount(memories, strategy) {
+    const maxPerActor = strategy.maxPerActor ?? 100;
+    const grouped = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      const list = grouped.get(m.actorId) || [];
+      list.push(m);
+      grouped.set(m.actorId, list);
+    }
+    const kept = [];
+    for (const [, actorMemories] of grouped) {
+      const sorted = [...actorMemories].sort((a, b) => b.importance - a.importance);
+      kept.push(...sorted.slice(0, maxPerActor));
+    }
+    return kept;
+  }
+  /** Remove memories of specified types. Opposite of filtering — removes the matches. */
+  removeByType(memories, strategy) {
+    if (!strategy.memoryTypes || strategy.memoryTypes.length === 0) return memories;
+    return memories.filter((m) => !strategy.memoryTypes.includes(m.memoryType));
+  }
+  /** Remove memories matching the predicate. Predicate returns true = should be removed. */
+  removeCustom(memories, strategy) {
+    if (!strategy.shouldRemove) return memories;
+    return memories.filter((m) => !strategy.shouldRemove(m));
+  }
+};
+
+// src/memory/ContextCompiler.ts
+var ContextCompiler = class {
+  /**
+   * Estimate token count from text using a blended heuristic.
+   * Combines word-based (prose) and character-based (code/json) estimates,
+   * taking the max to handle arbitrary content types.
+   */
+  estimateTokens(text) {
+    const charEst = Math.ceil(text.length / 4);
+    const words = text.split(/\s+/).filter((w) => w.length > 0);
+    const wordEst = Math.ceil(words.length * 1.3);
+    return Math.max(charEst, Math.max(1, wordEst));
+  }
+  /**
+   * Truncate text to fit within a token budget, preserving whole words.
+   * Appends "..." when content is cut. Falls back to character-based
+   * truncation for text with few/no word boundaries.
+   */
+  truncateToTokens(text, maxTokens) {
+    if (this.estimateTokens(text) <= maxTokens) return text;
+    const words = text.split(/\s+/);
+    const targetWords = Math.max(1, Math.floor(maxTokens / 1.3));
+    let currentTokens = 0;
+    let i = 0;
+    for (; i < words.length && i < targetWords; i++) {
+      currentTokens += this.estimateTokens(words[i]);
+      if (currentTokens > maxTokens) break;
+    }
+    if (i >= words.length) return text;
+    if (i > 0) return words.slice(0, i).join(" ") + "...";
+    const charLimit = maxTokens * 4;
+    return text.slice(0, charLimit) + "...";
+  }
+  compile(memories, options) {
+    const maxTokens = options.maxTokens ?? 2e3;
+    const relevant = memories.filter((m) => {
+      if (options.memoryTypes && options.memoryTypes.length > 0) {
+        return options.memoryTypes.includes(m.memoryType);
+      }
+      return true;
+    });
+    const sortedRecent = [...relevant].sort(
+      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+    );
+    const sortedImportant = this.deduplicate(
+      [...relevant].filter((m) => m.importance >= 0.5).sort((a, b) => b.importance - a.importance)
+    );
+    const { recentMemories, importantMemories, systemPrompt } = this.assembleTokenBudgeted(sortedRecent, sortedImportant, maxTokens);
+    const tokenEstimate = this.estimateTokens(systemPrompt);
+    return { systemPrompt, recentMemories, importantMemories, tokenEstimate };
+  }
+  assembleTokenBudgeted(recent, important, maxTokens) {
+    const includedImportant = [];
+    const includedRecent = [];
+    const seen = /* @__PURE__ */ new Set();
+    let usedTokens = 0;
+    for (const m of important) {
+      if (seen.has(m.id)) continue;
+      const prefix = `- `;
+      const suffix = ` (${m.memoryType}, importance: ${m.importance.toFixed(2)})
+`;
+      const overhead = this.estimateTokens(prefix + suffix);
+      let tokens = this.estimateTokens(m.content) + overhead;
+      const remaining = Math.floor(maxTokens * 0.6) - usedTokens;
+      if (remaining <= 0) break;
+      if (tokens > remaining) {
+        const contentBudget = Math.max(0, remaining - overhead);
+        if (contentBudget > 0) {
+          const truncatedContent = this.truncateToTokens(m.content, contentBudget);
+          includedImportant.push({ ...m, content: truncatedContent });
+          tokens = this.estimateTokens(truncatedContent) + overhead;
+          usedTokens += tokens;
+          seen.add(m.id);
+        }
+      } else {
+        includedImportant.push(m);
+        usedTokens += tokens;
+        seen.add(m.id);
+      }
+    }
+    for (const m of recent) {
+      if (seen.has(m.id)) continue;
+      const prefix = `- `;
+      const suffix = `
+`;
+      const overhead = this.estimateTokens(prefix + suffix);
+      let tokens = this.estimateTokens(m.content) + overhead;
+      const remaining = maxTokens - usedTokens;
+      if (remaining <= 0) break;
+      if (tokens > remaining) {
+        const contentBudget = Math.max(0, remaining - overhead);
+        if (contentBudget > 0) {
+          const truncatedContent = this.truncateToTokens(m.content, contentBudget);
+          includedRecent.push({ ...m, content: truncatedContent });
+          tokens = this.estimateTokens(truncatedContent) + overhead;
+          usedTokens += tokens;
+          seen.add(m.id);
+        }
+      } else {
+        includedRecent.push(m);
+        usedTokens += tokens;
+        seen.add(m.id);
+      }
+    }
+    const parts = [];
+    if (includedImportant.length > 0) {
+      parts.push("## Important Memories");
+      for (const m of includedImportant) {
+        parts.push(`- ${m.content} (${m.memoryType}, importance: ${m.importance.toFixed(2)})`);
+      }
+    }
+    if (includedRecent.length > 0) {
+      parts.push("\n## Recent Interactions");
+      for (const m of includedRecent) {
+        parts.push(`- ${m.content}`);
+      }
+    }
+    return { recentMemories: includedRecent, importantMemories: includedImportant, systemPrompt: parts.join("\n") };
+  }
+  deduplicate(memories) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const m of memories) {
+      const key = m.content.toLowerCase().trim();
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(m);
+      }
+    }
+    return result;
+  }
+};
+
+// src/memory/MemoryStore.ts
+var EMBEDDING_BATCH_SIZE = 2048;
+var MemoryStore = class {
+  storage;
+  embedding;
+  summarizer;
+  pruner;
+  compiler;
+  embedOnStore;
+  constructor(config) {
+    this.storage = config.storage;
+    this.embedding = config.embedding;
+    this.embedOnStore = config.embedOnStore ?? true;
+    if (config.llm) {
+      this.summarizer = new Summarizer(config.llm, config.summarizationPrompt);
+    }
+    this.pruner = new Pruner();
+    this.compiler = new ContextCompiler();
+  }
+  async store(input) {
+    if (input.onConflict === "append") {
+      const hash = this._hashContent(input.actorId, input.content);
+      const existing = await this.storage.retrieve({ actorId: input.actorId, limit: 1e3 });
+      const match = existing.find(
+        (m) => this._hashContent(m.actorId, m.content) === hash
+      );
+      if (match) {
+        const mergedTags = [.../* @__PURE__ */ new Set([...match.tags ?? [], ...input.tags ?? []])];
+        const updated = await this.storage.store({
+          id: match.id,
+          actorId: match.actorId,
+          content: match.content,
+          memoryType: match.memoryType,
+          importance: input.importance ?? match.importance,
+          emotionalValence: input.emotionalValence ?? match.emotionalValence,
+          tags: mergedTags,
+          embedding: match.embedding,
+          sourceId: input.sourceId ?? match.sourceId,
+          metadata: { ...match.metadata, ...input.metadata },
+          expiresAt: input.expiresAt ?? match.expiresAt
+        });
+        return updated;
+      }
+    }
+    let withEmbedding = input;
+    if (this.embedding && this.embedOnStore) {
+      const embeddings = await this.embedding.embed([input.content]);
+      withEmbedding = { ...input, embedding: embeddings[0] };
+    }
+    const { onConflict: _, ...clean } = withEmbedding;
+    return this.storage.store(clean);
+  }
+  async storeBatch(inputs) {
+    const appendInputs = inputs.filter((i) => i.onConflict === "append");
+    const normalInputs = inputs.filter((i) => i.onConflict !== "append");
+    const results = [];
+    for (const input of appendInputs) {
+      results.push(await this.store(input));
+    }
+    if (normalInputs.length === 0) return results;
+    if (this.embedding && this.embedOnStore) {
+      for (let i = 0; i < normalInputs.length; i += EMBEDDING_BATCH_SIZE) {
+        const batch = normalInputs.slice(i, i + EMBEDDING_BATCH_SIZE);
+        const texts = batch.map((inp) => inp.content);
+        const embeddings = await this.embedding.embed(texts);
+        const enriched = batch.map((input, j) => ({ ...input, embedding: embeddings[j] }));
+        const stored = await this.storage.storeBatch(enriched);
+        results.push(...stored);
+      }
+    } else {
+      const stored = await this.storage.storeBatch(normalInputs);
+      results.push(...stored);
+    }
+    return results;
+  }
+  async get(id) {
+    return this.storage.get(id);
+  }
+  async delete(id) {
+    return this.storage.delete(id);
+  }
+  async deleteMany(ids) {
+    return this.storage.deleteMany(ids);
+  }
+  async touch(id) {
+    const memory = await this.storage.get(id);
+    if (!memory) throw notFound("Memory", id);
+    if (this.storage.touch) {
+      return this.storage.touch(id);
+    }
+    await this.storage.delete(id);
+    await this.storage.store({
+      actorId: memory.actorId,
+      content: memory.content,
+      memoryType: memory.memoryType,
+      importance: memory.importance,
+      emotionalValence: memory.emotionalValence,
+      tags: memory.tags,
+      embedding: memory.embedding,
+      sourceId: memory.sourceId,
+      metadata: memory.metadata,
+      expiresAt: memory.expiresAt
+    });
+  }
+  async count(filter) {
+    return this.storage.count(filter);
+  }
+  async retrieve(query) {
+    let embedding;
+    if (this.embedding && query.query && (query.strategy === "semantic" || query.strategy === "hybrid")) {
+      const vecs = await this.embedding.embed([query.query]);
+      embedding = vecs[0];
+    }
+    return this.storage.retrieve(query, embedding);
+  }
+  async compileContext(options) {
+    const maxTokens = options.maxTokens ?? 2e3;
+    const memories = await this.storage.retrieve({ actorId: options.actorId, limit: 50 });
+    return this.compiler.compile(memories, { ...options, maxTokens });
+  }
+  async summarize(options, onError) {
+    if (!this.summarizer) {
+      throw validationError("No LLM configured for summarization");
+    }
+    const allMemories = await this.storage.retrieve({
+      actorId: options.actorId,
+      memoryTypes: options.memoryTypes ?? ["interaction"],
+      limit: 1e3,
+      strategy: "recent"
+    });
+    let toSummarize = allMemories;
+    if (options.olderThan) {
+      toSummarize = toSummarize.filter((m) => m.createdAt < options.olderThan);
+    }
+    if (options.skipMostRecent) {
+      const sorted = [...toSummarize].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      toSummarize = sorted.slice(0, Math.max(0, sorted.length - options.skipMostRecent));
+    }
+    if (options.targetCount && toSummarize.length > options.targetCount) {
+      const sorted = [...toSummarize].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      toSummarize = sorted.slice(0, options.targetCount);
+    }
+    if (toSummarize.length === 0) {
+      throw validationError("No memories to summarize");
+    }
+    let summaryContent;
+    try {
+      const result = await this.summarizer.summarize(toSummarize, options);
+      summaryContent = result.summaryContent;
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
+    const summary = await this.storage.store({
+      actorId: options.actorId ?? toSummarize[0].actorId,
+      content: summaryContent,
+      memoryType: "summary",
+      importance: Math.max(...toSummarize.map((m) => m.importance)),
+      emotionalValence: toSummarize.reduce((sum, m) => sum + m.emotionalValence, 0) / toSummarize.length,
+      tags: ["summary"],
+      sourceId: toSummarize[0].id
+    });
+    let deletedCount = 0;
+    if (!options.keepOriginals) {
+      const ids = toSummarize.map((m) => m.id);
+      deletedCount = await this.storage.deleteMany(ids);
+    }
+    return { summary, deletedCount };
+  }
+  async prune(strategy) {
+    const allMemories = await this.storage.retrieve({ limit: 1e4 });
+    const kept = this.pruner.execute(allMemories, strategy);
+    const keptIds = new Set(kept.map((k) => k.id));
+    const prunedIds = allMemories.filter((m) => !keptIds.has(m.id)).map((m) => m.id);
+    let count = 0;
+    if (prunedIds.length > 0) {
+      count = await this.storage.deleteMany(prunedIds);
+    }
+    return { pruned: prunedIds, count };
+  }
+  async dryRunPrune(strategy) {
+    const allMemories = await this.storage.retrieve({ limit: 1e4 });
+    const kept = this.pruner.execute(allMemories, strategy);
+    const keptIds = new Set(kept.map((k) => k.id));
+    const wouldPrune = allMemories.filter((m) => !keptIds.has(m.id)).map((m) => m.id);
+    return { wouldPrune, count: wouldPrune.length };
+  }
+  async export() {
+    return this.storage.retrieve({ limit: 1e5 });
+  }
+  _hashContent(actorId, content) {
+    const normalized = `${actorId}::${content.toLowerCase().trim()}`;
+    let hash = 14695981039346656037n;
+    for (let i = 0; i < normalized.length; i++) {
+      hash ^= BigInt(normalized.charCodeAt(i));
+      hash *= 1099511628211n;
+    }
+    return hash.toString(36);
+  }
+};
+
+// src/adapters/storage/memory.ts
+var InMemoryStorage = class {
+  memories = /* @__PURE__ */ new Map();
+  async initialize() {
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      _touchedAt: now
+    };
+    this.memories.set(memory.id, memory);
+    return memory;
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const memory = this.memories.get(id);
+    if (!memory) return null;
+    if (memory.expiresAt && memory.expiresAt <= /* @__PURE__ */ new Date()) {
+      this.memories.delete(id);
+      return null;
+    }
+    return memory;
+  }
+  async delete(id) {
+    if (!this.memories.has(id)) throw notFound("Memory", id);
+    this.memories.delete(id);
+  }
+  async deleteMany(ids) {
+    let count = 0;
+    for (const id of ids) {
+      if (this.memories.has(id)) {
+        this.memories.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+  async retrieve(query, _embedding) {
+    let results = Array.from(this.memories.values());
+    const now = /* @__PURE__ */ new Date();
+    results = results.filter((m) => !m.expiresAt || m.expiresAt > now);
+    if (query.actorId) {
+      results = results.filter((m) => m.actorId === query.actorId);
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      results = results.filter((m) => query.memoryTypes.includes(m.memoryType));
+    }
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((m) => m.tags?.some((t) => query.tags.includes(t)));
+    }
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((m) => m.content.toLowerCase().includes(q));
+    }
+    switch (query.strategy) {
+      case "recent":
+        results.sort((a, b) => b._touchedAt.getTime() - a._touchedAt.getTime());
+        break;
+      case "important":
+        results.sort((a, b) => b.importance - a.importance);
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        results.sort((a, b) => b.importance - a.importance || b._touchedAt.getTime() - a._touchedAt.getTime());
+        break;
+    }
+    for (const r of results.slice(0, query.limit ?? 10)) {
+      r._touchedAt = /* @__PURE__ */ new Date();
+    }
+    const limit = query.limit ?? 10;
+    return results.slice(0, limit);
+  }
+  async count(filter) {
+    const now = /* @__PURE__ */ new Date();
+    let results = Array.from(this.memories.values()).filter((m) => !m.expiresAt || m.expiresAt > now);
+    if (filter?.actorId) {
+      results = results.filter((m) => m.actorId === filter.actorId);
+    }
+    if (filter?.memoryType) {
+      results = results.filter((m) => m.memoryType === filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      results = results.filter((m) => m.importance >= filter.minImportance);
+    }
+    return results.length;
+  }
+  async touch(id) {
+    const memory = this.memories.get(id);
+    if (!memory) throw notFound("Memory", id);
+    memory._touchedAt = /* @__PURE__ */ new Date();
+  }
+  async close() {
+    this.memories.clear();
+  }
+  getAllMemories() {
+    return Array.from(this.memories.values());
+  }
+};
+
+// src/client.ts
+var MemStack = class {
+  memory;
+  config;
+  storage;
+  processCount = 0;
+  constructor(config) {
+    if (!config.llm) {
+      throw configError("LLM provider is required");
+    }
+    this.config = config;
+    this.storage = config.storage ?? new InMemoryStorage();
+    this.memory = new MemoryStore({
+      storage: this.storage,
+      embedding: config.embedding,
+      llm: config.llm,
+      embedOnStore: config.defaults?.embedOnStore ?? true,
+      summarizationPrompt: config.defaults?.summarizationPrompt
+    });
+  }
+  async process(input) {
+    let importance = input.importance;
+    let tags = input.tags;
+    const needImportance = importance === void 0 && this.config.defaults?.autoImportance;
+    const needTags = (!tags || tags.length === 0) && this.config.defaults?.autoTags;
+    if (needImportance || needTags) {
+      try {
+        if (needImportance && needTags) {
+          const result = await this.config.llm.complete({
+            system: 'Analyze the memory and respond with a JSON object: {"importance": <0.0-1.0>, "tags": [<array of 1-5 lowercase single-word tags>]}. Return ONLY the JSON, nothing else.',
+            user: input.content,
+            maxTokens: 100,
+            temperature: 0
+          });
+          const parsed = this._parseEnrichmentJson(result.text);
+          if (parsed.importance !== void 0) importance = parsed.importance;
+          if (parsed.tags) tags = parsed.tags;
+        } else if (needImportance) {
+          const result = await this.config.llm.complete({
+            system: "Rate the importance of the following memory for an AI agent on a scale of 0.0 to 1.0, where 0.0 is trivial and 1.0 is critical. Return ONLY a single float number, nothing else.",
+            user: input.content,
+            maxTokens: 10,
+            temperature: 0
+          });
+          const parsed = parseFloat(result.text.trim());
+          importance = Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : 0.5;
+        } else if (needTags) {
+          const result = await this.config.llm.complete({
+            system: 'Extract 1-5 concise, lowercase, single-word tags from the following memory. Return ONLY a JSON array of strings, nothing else. Example: ["combat", "goblin", "forest"]',
+            user: input.content,
+            maxTokens: 80,
+            temperature: 0
+          });
+          tags = this._parseTagsJson(result.text);
+        }
+      } catch (err) {
+        this.config.hooks?.onError?.(
+          err instanceof Error ? err : new Error(String(err)),
+          "auto-enrich"
+        );
+        if (importance === void 0) importance = 0.5;
+        if (!tags) tags = [];
+      }
+    }
+    const memoryInput = {
+      actorId: input.actorId,
+      content: input.content,
+      memoryType: input.memoryType ?? "interaction",
+      importance: importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: tags ?? [],
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      onConflict: input.onConflict
+    };
+    const memory = await this.memory.store(memoryInput);
+    this.config.hooks?.onMemoryStored?.(memory);
+    this.processCount++;
+    let summaryCreated;
+    const threshold = this.config.defaults?.summarizationThreshold ?? 100;
+    if (threshold > 0) {
+      const count = await this.memory.count({ actorId: input.actorId, memoryType: "interaction" });
+      if (count % threshold === 0 && count > 0) {
+        try {
+          const result = await this.memory.summarize(
+            {
+              actorId: input.actorId,
+              memoryTypes: ["interaction"],
+              skipMostRecent: 5,
+              targetCount: Math.min(15, count)
+            },
+            this.config.hooks?.onError ? (err) => this.config.hooks.onError(err, "summarize") : void 0
+          );
+          summaryCreated = result.summary;
+          this.config.hooks?.onSummaryCreated?.(result.summary, result.deletedCount);
+        } catch (err) {
+          this.config.hooks?.onError?.(
+            err instanceof Error ? err : new Error(String(err)),
+            "summarize"
+          );
+        }
+      }
+    }
+    const pruneStrategy = this.config.defaults?.pruneStrategy;
+    const pruneInterval = this.config.defaults?.pruneInterval ?? 100;
+    if (pruneStrategy && this.processCount % pruneInterval === 0) {
+      try {
+        const pruneResult = await this.memory.prune(pruneStrategy);
+        if (pruneResult.count > 0) {
+          this.config.hooks?.onMemoryPruned?.(pruneResult.pruned);
+        }
+      } catch (err) {
+        this.config.hooks?.onError?.(
+          err instanceof Error ? err : new Error(String(err)),
+          "prune"
+        );
+      }
+    }
+    return { memory, summaryCreated };
+  }
+  async export() {
+    const memories = await this.memory.export();
+    return {
+      version: 1,
+      memories,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async import(snapshot) {
+    if (snapshot.version !== 1) {
+      throw validationError(`Unsupported snapshot version: ${snapshot.version}`);
+    }
+    await this.memory.storeBatch(snapshot.memories);
+  }
+  async health() {
+    const status = { storage: false, llm: false, embedding: false };
+    try {
+      await this.memory.count();
+      status.storage = true;
+    } catch {
+    }
+    try {
+      await this.config.llm.complete({ system: "ok", user: "health", maxTokens: 1 });
+      status.llm = true;
+    } catch {
+    }
+    if (this.config.embedding) {
+      try {
+        await this.config.embedding.embed(["health check"]);
+        status.embedding = true;
+      } catch {
+      }
+    }
+    return status;
+  }
+  async close() {
+    await this.storage.close();
+  }
+  _parseEnrichmentJson(text) {
+    try {
+      const json = JSON.parse(this._extractJson(text));
+      const result = {};
+      if (typeof json.importance === "number" && Number.isFinite(json.importance)) {
+        result.importance = Math.max(0, Math.min(1, json.importance));
+      }
+      if (Array.isArray(json.tags) && json.tags.every((t) => typeof t === "string")) {
+        result.tags = json.tags.map((t) => t.toLowerCase().trim()).slice(0, 5);
+      }
+      return result;
+    } catch {
+      return {};
+    }
+  }
+  _parseTagsJson(text) {
+    try {
+      const parsed = JSON.parse(this._extractJson(text));
+      if (Array.isArray(parsed) && parsed.every((t) => typeof t === "string")) {
+        return parsed.map((t) => t.toLowerCase().trim()).slice(0, 5);
+      }
+    } catch {
+    }
+    return text.split(",").map((t) => t.replace(/[\[\]"]/g, "").trim().toLowerCase()).filter((t) => t.length > 0).slice(0, 5);
+  }
+  /** Strip markdown code fences and extract the JSON payload from LLM output. */
+  _extractJson(text) {
+    let cleaned = text.trim();
+    const fenceMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) cleaned = fenceMatch[1].trim();
+    return cleaned;
+  }
+};
+var DiskStorage = class {
+  dir;
+  _writeLocks = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.dir = config.storageDir ?? "./memstack-data";
+  }
+  async initialize() {
+    await mkdir(this.dir, { recursive: true });
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      _touchedAt: now.toISOString()
+    };
+    await this._withWriteLock(input.actorId, async () => {
+      const records = await this._readFile(input.actorId);
+      const existingIdx = records.findIndex((r) => r.id === memory.id);
+      if (existingIdx !== -1) {
+        records[existingIdx] = memory;
+      } else {
+        records.push(memory);
+      }
+      await this._writeFile(input.actorId, records);
+    });
+    return this._toExternal(memory);
+  }
+  async storeBatch(inputs) {
+    const byActor = /* @__PURE__ */ new Map();
+    const now = /* @__PURE__ */ new Date();
+    const all = [];
+    for (const input of inputs) {
+      const memory = {
+        id: input.id ?? this.generateId(),
+        actorId: input.actorId,
+        memoryType: input.memoryType ?? "interaction",
+        content: input.content,
+        importance: input.importance ?? 0.5,
+        emotionalValence: input.emotionalValence ?? 0,
+        tags: input.tags ?? [],
+        embedding: input.embedding,
+        sourceId: input.sourceId,
+        metadata: input.metadata ?? {},
+        expiresAt: input.expiresAt,
+        createdAt: now,
+        _touchedAt: now.toISOString()
+      };
+      all.push(memory);
+      const group = byActor.get(input.actorId) ?? [];
+      group.push(memory);
+      byActor.set(input.actorId, group);
+    }
+    for (const [actorId, group] of byActor) {
+      await this._withWriteLock(actorId, async () => {
+        const existing = await this._readFile(actorId);
+        for (const mem of group) {
+          const existingIdx = existing.findIndex((r) => r.id === mem.id);
+          if (existingIdx !== -1) {
+            existing[existingIdx] = mem;
+          } else {
+            existing.push(mem);
+          }
+        }
+        await this._writeFile(actorId, existing);
+      });
+    }
+    return all.map((m) => this._toExternal(m));
+  }
+  async get(id) {
+    const actorIds = await this._listActors();
+    for (const actorId of actorIds) {
+      const records = await this._readFile(actorId);
+      const record = records.find((r) => r.id === id);
+      if (record) {
+        if (record.expiresAt && new Date(record.expiresAt) <= /* @__PURE__ */ new Date()) return null;
+        return this._toExternal(record);
+      }
+    }
+    return null;
+  }
+  async delete(id) {
+    const actorIds = await this._listActors();
+    for (const actorId of actorIds) {
+      const records = await this._readFile(actorId);
+      const index = records.findIndex((r) => r.id === id);
+      if (index !== -1) {
+        await this._withWriteLock(actorId, async () => {
+          const fresh = await this._readFile(actorId);
+          const i = fresh.findIndex((r) => r.id === id);
+          if (i !== -1) {
+            fresh.splice(i, 1);
+            await this._writeFile(actorId, fresh);
+          }
+        });
+        return;
+      }
+    }
+    throw notFound("Memory", id);
+  }
+  async deleteMany(ids) {
+    const idSet = new Set(ids);
+    let count = 0;
+    const actorIds = await this._listActors();
+    for (const actorId of actorIds) {
+      await this._withWriteLock(actorId, async () => {
+        const records = await this._readFile(actorId);
+        const before = records.length;
+        const filtered = records.filter((r) => !idSet.has(r.id));
+        count += before - filtered.length;
+        if (before !== filtered.length) {
+          await this._writeFile(actorId, filtered);
+        }
+      });
+    }
+    return count;
+  }
+  async retrieve(query, _embedding) {
+    const actorIds = query.actorId ? [query.actorId] : await this._listActors();
+    let results = [];
+    for (const actorId of actorIds) {
+      let records = await this._readFile(actorId);
+      const now = /* @__PURE__ */ new Date();
+      records = records.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+      if (query.memoryTypes && query.memoryTypes.length > 0) {
+        records = records.filter((r) => query.memoryTypes.includes(r.memoryType));
+      }
+      if (query.tags && query.tags.length > 0) {
+        records = records.filter((r) => r.tags?.some((t) => query.tags.includes(t)));
+      }
+      if (query.query) {
+        const q = query.query.toLowerCase();
+        records = records.filter((r) => r.content.toLowerCase().includes(q));
+      }
+      results.push(...records);
+    }
+    switch (query.strategy) {
+      case "recent":
+        results.sort((a, b) => new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime());
+        break;
+      case "important":
+        results.sort((a, b) => b.importance - a.importance);
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        results.sort(
+          (a, b) => b.importance - a.importance || new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime()
+        );
+        break;
+    }
+    const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+    const toTouch = results.slice(0, query.limit ?? 10);
+    const touchedActors = /* @__PURE__ */ new Set();
+    for (const r of toTouch) {
+      r._touchedAt = nowStr;
+      touchedActors.add(r.actorId);
+    }
+    for (const actorId of touchedActors) {
+      await this._withWriteLock(actorId, async () => {
+        const records = await this._readFile(actorId);
+        let changed = false;
+        for (const r of records) {
+          const touched = toTouch.find((t) => t.id === r.id);
+          if (touched) {
+            r._touchedAt = nowStr;
+            changed = true;
+          }
+        }
+        if (changed) await this._writeFile(actorId, records);
+      });
+    }
+    const limit = query.limit ?? 10;
+    return results.slice(0, limit).map((r) => this._toExternal(r));
+  }
+  async count(filter) {
+    const actorIds = filter?.actorId ? [filter.actorId] : await this._listActors();
+    let total = 0;
+    const now = /* @__PURE__ */ new Date();
+    for (const actorId of actorIds) {
+      let records = await this._readFile(actorId);
+      records = records.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+      if (filter?.memoryType) {
+        records = records.filter((r) => r.memoryType === filter.memoryType);
+      }
+      if (filter?.minImportance !== void 0) {
+        records = records.filter((r) => r.importance >= filter.minImportance);
+      }
+      total += records.length;
+    }
+    return total;
+  }
+  async touch(id) {
+    const actorIds = await this._listActors();
+    for (const actorId of actorIds) {
+      const records = await this._readFile(actorId);
+      const found = records.find((r) => r.id === id);
+      if (found) {
+        const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+        await this._withWriteLock(actorId, async () => {
+          const fresh = await this._readFile(actorId);
+          const match = fresh.find((r) => r.id === id);
+          if (match) {
+            match._touchedAt = nowStr;
+            await this._writeFile(actorId, fresh);
+          }
+        });
+        return;
+      }
+    }
+    throw notFound("Memory", id);
+  }
+  async close() {
+    this._writeLocks.clear();
+  }
+  // ── Internal ──
+  _filePath(actorId) {
+    const safe = actorId.replace(/[^a-zA-Z0-9_\-.,@]/g, "_");
+    return join(this.dir, `${safe}.json`);
+  }
+  async _readFile(actorId) {
+    try {
+      const raw = await readFile(this._filePath(actorId), "utf-8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw storageError(`Failed to read memories for actor ${actorId}: ${err.message}`);
+    }
+  }
+  async _writeFile(actorId, records) {
+    try {
+      await writeFile(this._filePath(actorId), JSON.stringify(records, null, 2), "utf-8");
+    } catch (err) {
+      throw storageError(`Failed to write memories for actor ${actorId}: ${err.message}`);
+    }
+  }
+  async _withWriteLock(actorId, fn) {
+    const prev = this._writeLocks.get(actorId) ?? Promise.resolve();
+    let resolve;
+    const next = new Promise((r) => {
+      resolve = r;
+    });
+    this._writeLocks.set(actorId, next);
+    await prev;
+    try {
+      await fn();
+    } finally {
+      resolve();
+      if (this._writeLocks.get(actorId) === next) {
+        this._writeLocks.delete(actorId);
+      }
+    }
+  }
+  async _listActors() {
+    try {
+      const entries = await readdir(this.dir);
+      return entries.filter((e) => e.endsWith(".json")).map((e) => e.slice(0, -5));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw storageError(`Failed to list actors: ${err.message}`);
+    }
+  }
+  _toExternal(record) {
+    const { _touchedAt: _, ...rest } = record;
+    return {
+      ...rest,
+      createdAt: new Date(record.createdAt),
+      expiresAt: record.expiresAt ? new Date(record.expiresAt) : void 0
+    };
+  }
+};
+
+// src/adapters/storage/redis.ts
+var RedisStorage = class {
+  redis;
+  prefix;
+  constructor(config) {
+    this.redis = config.redis;
+    this.prefix = config.keyPrefix ?? "memstack";
+  }
+  async initialize() {
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = /* @__PURE__ */ new Date();
+    const memory = {
+      id: input.id ?? this.generateId(),
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      _touchedAt: now.toISOString()
+    };
+    await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
+    await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
+    await this.redis.sadd(this._actorsSetKey(), memory.actorId);
+    return this._toExternal(memory);
+  }
+  async storeBatch(inputs) {
+    let results = [];
+    const now = /* @__PURE__ */ new Date();
+    for (const input of inputs) {
+      const memory = {
+        id: input.id ?? this.generateId(),
+        actorId: input.actorId,
+        memoryType: input.memoryType ?? "interaction",
+        content: input.content,
+        importance: input.importance ?? 0.5,
+        emotionalValence: input.emotionalValence ?? 0,
+        tags: input.tags ?? [],
+        embedding: input.embedding,
+        sourceId: input.sourceId,
+        metadata: input.metadata ?? {},
+        expiresAt: input.expiresAt,
+        createdAt: now,
+        _touchedAt: now.toISOString()
+      };
+      await this.redis.set(this._memKey(memory.id), JSON.stringify(memory));
+      await this.redis.sadd(this._actorKey(memory.actorId), memory.id);
+      await this.redis.sadd(this._actorsSetKey(), memory.actorId);
+      results.push(this._toExternal(memory));
+    }
+    return results;
+  }
+  async get(id) {
+    const raw = await this.redis.get(this._memKey(id));
+    if (!raw) return null;
+    const record = JSON.parse(raw);
+    if (record.expiresAt && new Date(record.expiresAt) <= /* @__PURE__ */ new Date()) return null;
+    return this._toExternal(record);
+  }
+  async delete(id) {
+    const raw = await this.redis.get(this._memKey(id));
+    if (!raw) throw notFound("Memory", id);
+    const record = JSON.parse(raw);
+    await this.redis.del(this._memKey(id));
+    await this.redis.srem(this._actorKey(record.actorId), id);
+  }
+  async deleteMany(ids) {
+    let count = 0;
+    const byActor = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const raw = await this.redis.get(this._memKey(id));
+      if (raw) {
+        const record = JSON.parse(raw);
+        const list = byActor.get(record.actorId) ?? [];
+        list.push(id);
+        byActor.set(record.actorId, list);
+      }
+    }
+    for (const [actorId, memIds] of byActor) {
+      await this.redis.del(memIds.map((id) => this._memKey(id)));
+      await this.redis.srem(this._actorKey(actorId), ...memIds);
+      count += memIds.length;
+    }
+    return count;
+  }
+  async retrieve(query, _embedding) {
+    let allRecords = [];
+    if (query.actorId) {
+      allRecords = await this._getActorRecords(query.actorId);
+    } else {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        const records = await this._getActorRecords(actorId);
+        allRecords.push(...records);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      results = results.filter((r) => query.memoryTypes.includes(r.memoryType));
+    }
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((r) => r.tags?.some((t) => query.tags.includes(t)));
+    }
+    if (query.query) {
+      const q = query.query.toLowerCase();
+      results = results.filter((r) => r.content.toLowerCase().includes(q));
+    }
+    switch (query.strategy) {
+      case "recent":
+        results.sort((a, b) => new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime());
+        break;
+      case "important":
+        results.sort((a, b) => b.importance - a.importance);
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        results.sort(
+          (a, b) => b.importance - a.importance || new Date(b._touchedAt).getTime() - new Date(a._touchedAt).getTime()
+        );
+        break;
+    }
+    const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+    const toTouch = results.slice(0, query.limit ?? 10);
+    for (const r of toTouch) {
+      r._touchedAt = nowStr;
+      await this.redis.set(this._memKey(r.id), JSON.stringify(r));
+    }
+    const limit = query.limit ?? 10;
+    return results.slice(0, limit).map((r) => this._toExternal(r));
+  }
+  async count(filter) {
+    let allRecords = [];
+    if (filter?.actorId) {
+      allRecords = await this._getActorRecords(filter.actorId);
+    } else {
+      const actorIds = await this._listActors();
+      for (const actorId of actorIds) {
+        const records = await this._getActorRecords(actorId);
+        allRecords.push(...records);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    let results = allRecords.filter((r) => !r.expiresAt || new Date(r.expiresAt) > now);
+    if (filter?.memoryType) {
+      results = results.filter((r) => r.memoryType === filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      results = results.filter((r) => r.importance >= filter.minImportance);
+    }
+    return results.length;
+  }
+  async close() {
+  }
+  // ── Internal ──
+  _actorsSetKey() {
+    return `${this.prefix}:actors`;
+  }
+  _actorKey(actorId) {
+    const safe = actorId.replace(/[^a-zA-Z0-9_\-.,@]/g, "_");
+    return `${this.prefix}:a:${safe}`;
+  }
+  _memKey(id) {
+    return `${this.prefix}:m:${id}`;
+  }
+  async _getActorRecords(actorId) {
+    const ids = await this.redis.smembers(this._actorKey(actorId));
+    if (ids.length === 0) return [];
+    const keys = ids.map((id) => this._memKey(id));
+    const raws = await this.redis.mget(...keys);
+    const records = [];
+    for (const raw of raws) {
+      if (raw) {
+        try {
+          records.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+    }
+    return records;
+  }
+  async _listActors() {
+    return this.redis.smembers(this._actorsSetKey());
+  }
+  _toExternal(record) {
+    const { _touchedAt: _, ...rest } = record;
+    return {
+      ...rest,
+      createdAt: new Date(record.createdAt),
+      expiresAt: record.expiresAt ? new Date(record.expiresAt) : void 0
+    };
+  }
+};
+
+// src/adapters/storage/postgres.ts
+var PostgresStorage = class {
+  pool;
+  table;
+  autoMigrate;
+  constructor(config) {
+    this.pool = config.pool;
+    this.table = config.tableName ?? "memstack_memories";
+    if (!/^[a-zA-Z0-9_]+$/.test(this.table)) {
+      throw new Error(`Invalid table name: "${this.table}". Use only alphanumeric characters and underscores.`);
+    }
+    this.autoMigrate = config.autoMigrate ?? true;
+  }
+  async initialize() {
+    if (!this.autoMigrate) return;
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        id TEXT PRIMARY KEY,
+        actor_id TEXT NOT NULL,
+        memory_type TEXT NOT NULL DEFAULT 'interaction',
+        content TEXT NOT NULL,
+        importance REAL NOT NULL DEFAULT 0.5,
+        emotional_valence REAL NOT NULL DEFAULT 0,
+        tags JSONB NOT NULL DEFAULT '[]',
+        embedding vector(3072),
+        source_id TEXT,
+        metadata JSONB NOT NULL DEFAULT '{}',
+        expires_at TIMESTAMPTZ,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        touched_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    try {
+      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_actor ON ${this.table} (actor_id)`);
+      await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_${this.table}_type ON ${this.table} (memory_type)`);
+    } catch {
+    }
+  }
+  generateId() {
+    return `mem_${Date.now().toString(36)}_${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async store(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = input.id ?? this.generateId();
+    await this.pool.query(
+      `INSERT INTO ${this.table} (id, actor_id, memory_type, content, importance, emotional_valence, tags, embedding, source_id, metadata, expires_at, created_at, touched_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8::float8[]::vector, $9, $10, $11, $12, $13)
+       ON CONFLICT (id) DO UPDATE SET
+         content = EXCLUDED.content,
+         importance = EXCLUDED.importance,
+         emotional_valence = EXCLUDED.emotional_valence,
+         tags = EXCLUDED.tags,
+         embedding = EXCLUDED.embedding,
+         source_id = EXCLUDED.source_id,
+         metadata = EXCLUDED.metadata,
+         expires_at = EXCLUDED.expires_at,
+         touched_at = EXCLUDED.touched_at`,
+      [
+        id,
+        input.actorId,
+        input.memoryType ?? "interaction",
+        input.content,
+        input.importance ?? 0.5,
+        input.emotionalValence ?? 0,
+        JSON.stringify(input.tags ?? []),
+        input.embedding ? `{${input.embedding.join(",")}}` : null,
+        input.sourceId ?? null,
+        JSON.stringify(input.metadata ?? {}),
+        input.expiresAt?.toISOString() ?? null,
+        now,
+        now
+      ]
+    );
+    return {
+      id,
+      actorId: input.actorId,
+      memoryType: input.memoryType ?? "interaction",
+      content: input.content,
+      importance: input.importance ?? 0.5,
+      emotionalValence: input.emotionalValence ?? 0,
+      tags: input.tags ?? [],
+      embedding: input.embedding,
+      sourceId: input.sourceId,
+      metadata: input.metadata ?? {},
+      expiresAt: input.expiresAt,
+      createdAt: new Date(now)
+    };
+  }
+  async storeBatch(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.store(input));
+    }
+    return results;
+  }
+  async get(id) {
+    const { rows } = await this.pool.query(
+      `SELECT * FROM ${this.table} WHERE id = $1 AND (expires_at IS NULL OR expires_at > NOW())`,
+      [id]
+    );
+    if (rows.length === 0) return null;
+    return this._rowToMemory(rows[0]);
+  }
+  async delete(id) {
+    const { rows } = await this.pool.query(`SELECT id FROM ${this.table} WHERE id = $1`, [id]);
+    if (rows.length === 0) throw notFound("Memory", id);
+    await this.pool.query(`DELETE FROM ${this.table} WHERE id = $1`, [id]);
+  }
+  async deleteMany(ids) {
+    const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
+    const { rows } = await this.pool.query(
+      `DELETE FROM ${this.table} WHERE id IN (${placeholders}) RETURNING id`,
+      ids
+    );
+    return rows.length;
+  }
+  async retrieve(query, embedding) {
+    const conditions = ["(expires_at IS NULL OR expires_at > NOW())"];
+    const params = [];
+    let paramIdx = 1;
+    if (query.actorId) {
+      conditions.push(`actor_id = $${paramIdx++}`);
+      params.push(query.actorId);
+    }
+    if (query.memoryTypes && query.memoryTypes.length > 0) {
+      conditions.push(`memory_type = ANY($${paramIdx++})`);
+      params.push(query.memoryTypes);
+    }
+    if (query.tags && query.tags.length > 0) {
+      conditions.push(`tags ?| $${paramIdx++}`);
+      params.push(query.tags);
+    }
+    if (query.query) {
+      conditions.push(`content ILIKE $${paramIdx++}`);
+      params.push(`%${query.query}%`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let orderBy;
+    switch (query.strategy) {
+      case "recent":
+        orderBy = "touched_at DESC";
+        break;
+      case "important":
+        orderBy = "importance DESC";
+        break;
+      case "hybrid":
+      case "semantic":
+      default:
+        if (embedding && query.query) {
+          return this._semanticRetrieve(embedding, query, params, where);
+        }
+        orderBy = "importance DESC, touched_at DESC";
+        break;
+    }
+    const limit = query.limit ?? 10;
+    const sql = `SELECT * FROM ${this.table} ${where} ORDER BY ${orderBy} LIMIT $${paramIdx}`;
+    params.push(limit);
+    const { rows } = await this.pool.query(sql, params);
+    for (const row of rows.slice(0, limit)) {
+      const r = row;
+      await this.pool.query(
+        `UPDATE ${this.table} SET touched_at = NOW() WHERE id = $1`,
+        [r.id]
+      );
+    }
+    return rows.map((r) => this._rowToMemory(r));
+  }
+  async count(filter) {
+    const conditions = ["(expires_at IS NULL OR expires_at > NOW())"];
+    const params = [];
+    let paramIdx = 1;
+    if (filter?.actorId) {
+      conditions.push(`actor_id = $${paramIdx++}`);
+      params.push(filter.actorId);
+    }
+    if (filter?.memoryType) {
+      conditions.push(`memory_type = $${paramIdx++}`);
+      params.push(filter.memoryType);
+    }
+    if (filter?.minImportance !== void 0) {
+      conditions.push(`importance >= $${paramIdx++}`);
+      params.push(filter.minImportance);
+    }
+    const where = conditions.join(" AND ");
+    const { rows } = await this.pool.query(
+      `SELECT COUNT(*) as count FROM ${this.table} WHERE ${where}`,
+      params
+    );
+    return Number(rows[0].count);
+  }
+  async close() {
+  }
+  // ── Internal ──
+  async _semanticRetrieve(embedding, query, params, baseWhere) {
+    const vecParam = `{${embedding.join(",")}}`;
+    const limit = query.limit ?? 10;
+    const conditions = baseWhere.replace(/^WHERE\s+/i, "");
+    const whereClause = conditions ? `WHERE ${conditions} AND embedding IS NOT NULL` : `WHERE embedding IS NOT NULL`;
+    const sql = `
+      SELECT *,
+        (embedding <-> $${params.length + 1}::float8[]::vector) AS distance
+      FROM ${this.table}
+      ${whereClause}
+      ORDER BY distance ASC
+      LIMIT $${params.length + 2}
+    `;
+    params.push(vecParam);
+    params.push(limit);
+    const { rows } = await this.pool.query(sql, params);
+    for (const row of rows.slice(0, limit)) {
+      const r = row;
+      await this.pool.query(`UPDATE ${this.table} SET touched_at = NOW() WHERE id = $1`, [r.id]);
+    }
+    return rows.map((r) => this._rowToMemory(r));
+  }
+  _rowToMemory(row) {
+    return {
+      id: row.id,
+      actorId: row.actor_id,
+      memoryType: row.memory_type,
+      content: row.content,
+      importance: row.importance,
+      emotionalValence: row.emotional_valence,
+      tags: Array.isArray(row.tags) ? row.tags : [],
+      embedding: row.embedding ?? void 0,
+      sourceId: row.source_id ?? void 0,
+      metadata: row.metadata ?? {},
+      expiresAt: row.expires_at ? new Date(row.expires_at) : void 0,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
+// src/adapters/llm/openai.ts
+var OpenAILLMAdapter = class {
+  apiKey;
+  baseURL;
+  defaultModel;
+  defaultTemperature;
+  defaultMaxTokens;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? "https://api.openai.com/v1";
+    this.defaultModel = config.defaultModel ?? "gpt-4o-mini";
+    this.defaultTemperature = config.defaultTemperature ?? 0.7;
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const temperature = request.temperature ?? this.defaultTemperature;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    try {
+      const response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: request.system },
+            { role: "user", content: request.user }
+          ],
+          temperature,
+          max_tokens: maxTokens
+        })
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        throw new MemStackError("LLM_ERROR", `OpenAI API error: ${response.status} ${err}`, {
+          retryable: response.status >= 500
+        });
+      }
+      const data = await response.json();
+      return {
+        text: data.choices[0]?.message?.content ?? "",
+        tokens: {
+          prompt: data.usage?.prompt_tokens ?? 0,
+          completion: data.usage?.completion_tokens ?? 0,
+          total: data.usage?.total_tokens ?? 0
+        }
+      };
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError("LLM_ERROR", `LLM request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+  }
+  async *completeStream(request) {
+    const model = request.model ?? this.defaultModel;
+    const temperature = request.temperature ?? this.defaultTemperature;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    let response;
+    try {
+      response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: request.system },
+            { role: "user", content: request.user }
+          ],
+          temperature,
+          max_tokens: maxTokens,
+          stream: true,
+          stream_options: { include_usage: true }
+        })
+      });
+    } catch (err) {
+      throw new MemStackError("LLM_ERROR", `OpenAI streaming request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+    if (!response.ok) {
+      const err = await response.text();
+      throw new MemStackError("LLM_ERROR", `OpenAI streaming error: ${response.status} ${err}`, {
+        retryable: response.status >= 500
+      });
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new MemStackError("LLM_ERROR", "No response body for streaming");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content ?? "";
+            if (parsed.usage) {
+              promptTokens = parsed.usage.prompt_tokens;
+              completionTokens = parsed.usage.completion_tokens;
+            }
+            if (content) {
+              yield {
+                text: content,
+                tokens: { prompt: promptTokens, completion: completionTokens, total: promptTokens + completionTokens }
+              };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/adapters/llm/anthropic.ts
+var AnthropicLLMAdapter = class {
+  apiKey;
+  baseURL;
+  defaultModel;
+  defaultMaxTokens;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  sdk;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? "https://api.anthropic.com";
+    this.defaultModel = config.defaultModel ?? "claude-sonnet-4-5-20250929";
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    try {
+      if (!this.sdk) {
+        const { default: Anthropic } = await import('@anthropic-ai/sdk');
+        this.sdk = new Anthropic({ apiKey: this.apiKey, baseURL: this.baseURL });
+      }
+      const response = await this.sdk.messages.create({
+        model,
+        system: request.system,
+        messages: [{ role: "user", content: request.user }],
+        max_tokens: maxTokens,
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+      });
+      const text = response.content.length > 0 && "text" in response.content[0] ? response.content[0].text : "";
+      return {
+        text,
+        tokens: {
+          prompt: response.usage?.input_tokens ?? 0,
+          completion: response.usage?.output_tokens ?? 0,
+          total: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
+        }
+      };
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError("LLM_ERROR", `Anthropic request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+  }
+};
+
+// src/adapters/embedding/openai.ts
+var OpenAIEmbeddingAdapter = class {
+  apiKey;
+  baseURL;
+  model;
+  dimensions;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? "https://api.openai.com/v1";
+    this.model = config.model ?? "text-embedding-3-small";
+    this.dimensions = this.model === "text-embedding-3-large" ? 3072 : 1536;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    if (texts.length > 2048) {
+      throw new MemStackError("VALIDATION_ERROR", `Max 2048 texts per batch, got ${texts.length}`);
+    }
+    try {
+      const response = await fetch(`${this.baseURL}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          input: texts
+        })
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        throw new MemStackError("EMBEDDING_ERROR", `OpenAI Embedding error: ${response.status} ${err}`, {
+          retryable: response.status >= 500
+        });
+      }
+      const data = await response.json();
+      return data.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError(
+        "EMBEDDING_ERROR",
+        `Embedding request failed: ${err instanceof Error ? err.message : String(err)}`,
+        { retryable: true }
+      );
+    }
+  }
+};
+
+// src/adapters/embedding/cohere.ts
+var DIMENSIONS = {
+  "embed-english-v3.0": 1024,
+  "embed-multilingual-v3.0": 1024,
+  "embed-english-light-v3.0": 384,
+  "embed-multilingual-light-v3.0": 384,
+  "embed-english-v2.0": 4096,
+  "embed-multilingual-v2.0": 768
+};
+var CohereEmbeddingAdapter = class {
+  apiKey;
+  baseURL;
+  model;
+  dimensions;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? "https://api.cohere.ai/v1";
+    this.model = config.model ?? "embed-english-v3.0";
+    this.dimensions = DIMENSIONS[this.model] ?? 1024;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    if (texts.length > 96) {
+      throw new MemStackError("VALIDATION_ERROR", `Cohere max 96 texts per batch, got ${texts.length}`);
+    }
+    try {
+      const response = await fetch(`${this.baseURL}/embed`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          texts,
+          input_type: "search_document",
+          embedding_types: ["float"]
+        })
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        throw new MemStackError("EMBEDDING_ERROR", `Cohere Embedding error: ${response.status} ${err}`, {
+          retryable: response.status >= 500
+        });
+      }
+      const data = await response.json();
+      return data.embeddings?.float ?? [];
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError(
+        "EMBEDDING_ERROR",
+        `Cohere embedding request failed: ${err instanceof Error ? err.message : String(err)}`,
+        { retryable: true }
+      );
+    }
+  }
+};
+
+// src/adapters/llm/ollama.ts
+var OllamaLLMAdapter = class {
+  baseURL;
+  defaultModel;
+  defaultTemperature;
+  defaultMaxTokens;
+  constructor(config = {}) {
+    this.baseURL = config.baseURL ?? "http://localhost:11434";
+    this.defaultModel = config.defaultModel ?? "llama3.2";
+    this.defaultTemperature = config.defaultTemperature ?? 0.7;
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const temperature = request.temperature ?? this.defaultTemperature;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    try {
+      const response = await fetch(`${this.baseURL}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: request.system },
+            { role: "user", content: request.user }
+          ],
+          options: { temperature, num_predict: maxTokens },
+          stream: false
+        })
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        throw new MemStackError("LLM_ERROR", `Ollama API error: ${response.status} ${err}`, {
+          retryable: response.status >= 500
+        });
+      }
+      const data = await response.json();
+      const promptTokens = data.prompt_eval_count ?? 0;
+      const completionTokens = data.eval_count ?? 0;
+      return {
+        text: data.message?.content ?? "",
+        tokens: {
+          prompt: promptTokens,
+          completion: completionTokens,
+          total: promptTokens + completionTokens
+        }
+      };
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError("LLM_ERROR", `Ollama request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+  }
+};
+
+// src/adapters/llm/groq.ts
+var GroqLLMAdapter = class {
+  apiKey;
+  baseURL;
+  defaultModel;
+  defaultTemperature;
+  defaultMaxTokens;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL ?? "https://api.groq.com/openai/v1";
+    this.defaultModel = config.defaultModel ?? "llama-3.3-70b-versatile";
+    this.defaultTemperature = config.defaultTemperature ?? 0.7;
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 1024;
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const temperature = request.temperature ?? this.defaultTemperature;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    try {
+      const response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: request.system },
+            { role: "user", content: request.user }
+          ],
+          temperature,
+          max_tokens: maxTokens
+        })
+      });
+      if (!response.ok) {
+        const err = await response.text();
+        throw new MemStackError("LLM_ERROR", `Groq API error: ${response.status} ${err}`, {
+          retryable: response.status >= 500
+        });
+      }
+      const data = await response.json();
+      return {
+        text: data.choices[0]?.message?.content ?? "",
+        tokens: {
+          prompt: data.usage?.prompt_tokens ?? 0,
+          completion: data.usage?.completion_tokens ?? 0,
+          total: data.usage?.total_tokens ?? 0
+        }
+      };
+    } catch (err) {
+      if (err instanceof MemStackError) throw err;
+      throw new MemStackError("LLM_ERROR", `Groq request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+  }
+  async *completeStream(request) {
+    const model = request.model ?? this.defaultModel;
+    const temperature = request.temperature ?? this.defaultTemperature;
+    const maxTokens = request.maxTokens ?? this.defaultMaxTokens;
+    let response;
+    try {
+      response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: request.system },
+            { role: "user", content: request.user }
+          ],
+          temperature,
+          max_tokens: maxTokens,
+          stream: true,
+          stream_options: { include_usage: true }
+        })
+      });
+    } catch (err) {
+      throw new MemStackError("LLM_ERROR", `Groq streaming request failed: ${err instanceof Error ? err.message : String(err)}`, {
+        retryable: true
+      });
+    }
+    if (!response.ok) {
+      const err = await response.text();
+      throw new MemStackError("LLM_ERROR", `Groq streaming error: ${response.status} ${err}`, {
+        retryable: response.status >= 500
+      });
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new MemStackError("LLM_ERROR", "No response body for streaming");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content ?? "";
+            const usage = parsed.usage ?? parsed.x_groq?.usage;
+            if (usage) {
+              promptTokens = usage.prompt_tokens;
+              completionTokens = usage.completion_tokens;
+            }
+            if (content) {
+              yield {
+                text: content,
+                tokens: { prompt: promptTokens, completion: completionTokens, total: promptTokens + completionTokens }
+              };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+export { AnthropicLLMAdapter, CohereEmbeddingAdapter, DiskStorage, GroqLLMAdapter, InMemoryStorage, MemStack, MemStackError, OllamaLLMAdapter, OpenAIEmbeddingAdapter, OpenAILLMAdapter, PostgresStorage, RedisStorage, configError, notFound, storageError, validationError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map