opensentinel 3.1.1 → 3.6.1

package/dist/chunk-6UZPE35A.js

@@ -0,0 +1,724 @@
+import {
+  db
+} from "./chunk-S4NJJS5C.js";
+import {
+  env
+} from "./chunk-PUNIMPMY.js";
+import {
+  archivedMemories,
+  memories
+} from "./chunk-NYVBXUGD.js";
+
+// src/core/embeddings/provider.ts
+var AbstractEmbeddingProvider = class {
+  async embedSingle(text) {
+    const [embedding] = await this.embed([text]);
+    return embedding;
+  }
+};
+var OpenAIEmbeddingProvider = class _OpenAIEmbeddingProvider extends AbstractEmbeddingProvider {
+  name = "openai";
+  dimensions;
+  apiKey;
+  model;
+  static MODEL_DIMENSIONS = {
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536
+  };
+  constructor(apiKey, model = "text-embedding-3-small") {
+    super();
+    this.apiKey = apiKey;
+    this.model = model;
+    this.dimensions = _OpenAIEmbeddingProvider.MODEL_DIMENSIONS[model] ?? 1536;
+  }
+  async embed(texts) {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ input: texts, model: this.model })
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI embedding failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.data.map((d) => d.embedding);
+  }
+};
+var HuggingFaceEmbeddingProvider = class extends AbstractEmbeddingProvider {
+  name = "huggingface";
+  dimensions;
+  accessToken;
+  model;
+  batchSize;
+  constructor(accessToken, model = "sentence-transformers/all-MiniLM-L6-v2", dimensions = 384, batchSize = 32) {
+    super();
+    this.accessToken = accessToken;
+    this.model = model;
+    this.dimensions = dimensions;
+    this.batchSize = batchSize;
+  }
+  async embed(texts) {
+    const allEmbeddings = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const batch = texts.slice(i, i + this.batchSize);
+      const embeddings = await this.embedBatch(batch);
+      allEmbeddings.push(...embeddings);
+    }
+    return allEmbeddings;
+  }
+  async embedBatch(texts, retries = 3) {
+    const url = `https://api-inference.huggingface.co/pipeline/feature-extraction/${this.model}`;
+    for (let attempt = 0; attempt < retries; attempt++) {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          inputs: texts,
+          options: { wait_for_model: true }
+        })
+      });
+      if (response.status === 429) {
+        const delay = Math.pow(2, attempt) * 1e3;
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      if (response.status === 503) {
+        const delay = Math.pow(2, attempt) * 2e3;
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(
+          `HuggingFace embedding failed: ${response.status} ${body}`
+        );
+      }
+      const data = await response.json();
+      return this.processResponse(data, texts.length);
+    }
+    throw new Error(
+      `HuggingFace embedding failed after ${retries} retries`
+    );
+  }
+  /**
+   * HuggingFace returns different shapes depending on the model:
+   * - Sentence-level: number[][] (one embedding per input)
+   * - Token-level: number[][][] (one embedding per token per input, needs mean pooling)
+   */
+  processResponse(data, expectedCount) {
+    if (!Array.isArray(data) || data.length === 0) {
+      throw new Error("HuggingFace returned empty response");
+    }
+    if (typeof data[0][0] === "number") {
+      return data.map((v) => this.l2Normalize(v));
+    }
+    if (Array.isArray(data[0][0])) {
+      return data.map(
+        (tokenEmbeddings) => this.l2Normalize(this.meanPool(tokenEmbeddings))
+      );
+    }
+    throw new Error(
+      `Unexpected HuggingFace response shape: ${typeof data[0][0]}`
+    );
+  }
+  meanPool(tokenEmbeddings) {
+    if (tokenEmbeddings.length === 0) return [];
+    const dims = tokenEmbeddings[0].length;
+    const result = new Array(dims).fill(0);
+    for (const token of tokenEmbeddings) {
+      for (let i = 0; i < dims; i++) {
+        result[i] += token[i];
+      }
+    }
+    const count = tokenEmbeddings.length;
+    for (let i = 0; i < dims; i++) {
+      result[i] /= count;
+    }
+    return result;
+  }
+  l2Normalize(vector) {
+    const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+    if (norm === 0) return vector;
+    return vector.map((v) => v / norm);
+  }
+};
+var TFIDFProvider = class extends AbstractEmbeddingProvider {
+  name = "tfidf";
+  dimensions = 256;
+  vocabulary = /* @__PURE__ */ new Map();
+  idf = /* @__PURE__ */ new Map();
+  docCount = 0;
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+  }
+  buildVocabulary(documents) {
+    this.docCount = documents.length;
+    const docFreq = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      const tokens = new Set(this.tokenize(doc));
+      for (const token of tokens) {
+        docFreq.set(token, (docFreq.get(token) || 0) + 1);
+      }
+    }
+    const sorted = Array.from(docFreq.entries()).sort((a, b) => b[1] - a[1]).slice(0, this.dimensions);
+    sorted.forEach(([term, df], i) => {
+      this.vocabulary.set(term, i);
+      this.idf.set(term, Math.log(this.docCount / (1 + df)));
+    });
+  }
+  async embed(texts) {
+    if (this.vocabulary.size === 0) {
+      this.buildVocabulary(texts);
+    }
+    return texts.map((text) => {
+      const tokens = this.tokenize(text);
+      const tf = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        tf.set(token, (tf.get(token) || 0) + 1);
+      }
+      const vector = new Array(this.dimensions).fill(0);
+      for (const [term, freq] of tf) {
+        const idx = this.vocabulary.get(term);
+        if (idx !== void 0) {
+          const tfidf = freq / tokens.length * (this.idf.get(term) || 1);
+          vector[idx] = tfidf;
+        }
+      }
+      const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+      if (norm > 0) {
+        for (let i = 0; i < vector.length; i++) {
+          vector[i] /= norm;
+        }
+      }
+      return vector;
+    });
+  }
+};
+
+// src/core/embeddings/adapter.ts
+var DimensionAdapter = class {
+  providerDimensions;
+  dbDimensions;
+  constructor(providerDimensions, dbDimensions) {
+    this.providerDimensions = providerDimensions;
+    this.dbDimensions = dbDimensions;
+  }
+  needsAdaptation() {
+    return this.providerDimensions !== this.dbDimensions;
+  }
+  adapt(embedding) {
+    if (embedding.length === this.dbDimensions) return embedding;
+    if (embedding.length < this.dbDimensions) {
+      const padded = new Array(this.dbDimensions).fill(0);
+      for (let i = 0; i < embedding.length; i++) {
+        padded[i] = embedding[i];
+      }
+      return padded;
+    }
+    return embedding.slice(0, this.dbDimensions);
+  }
+  adaptBatch(embeddings) {
+    if (!this.needsAdaptation()) return embeddings;
+    return embeddings.map((e) => this.adapt(e));
+  }
+  getProviderDimensions() {
+    return this.providerDimensions;
+  }
+  getDbDimensions() {
+    return this.dbDimensions;
+  }
+};
+
+// src/core/embeddings/registry.ts
+var MODEL_DIMENSIONS = {
+  // OpenAI
+  "text-embedding-3-small": 1536,
+  "text-embedding-3-large": 3072,
+  "text-embedding-ada-002": 1536,
+  // HuggingFace sentence-transformers
+  "sentence-transformers/all-MiniLM-L6-v2": 384,
+  "sentence-transformers/all-mpnet-base-v2": 768,
+  "sentence-transformers/all-MiniLM-L12-v2": 384,
+  "sentence-transformers/paraphrase-MiniLM-L6-v2": 384,
+  // BAAI
+  "BAAI/bge-small-en-v1.5": 384,
+  "BAAI/bge-base-en-v1.5": 768,
+  "BAAI/bge-large-en-v1.5": 1024
+};
+var EmbeddingRegistry = class {
+  provider = null;
+  adapter = null;
+  config = null;
+  initialize(provider, config) {
+    this.provider = provider;
+    this.config = config;
+    this.adapter = new DimensionAdapter(
+      provider.dimensions,
+      config.dbDimensions
+    );
+    if (this.adapter.needsAdaptation()) {
+      const action = provider.dimensions < config.dbDimensions ? "zero-padded" : "truncated";
+      console.log(
+        `[Embeddings] Provider: ${provider.name} (${provider.dimensions} dims, ${action} to ${config.dbDimensions})`
+      );
+    } else {
+      console.log(
+        `[Embeddings] Provider: ${provider.name} (${provider.dimensions} dims)`
+      );
+    }
+  }
+  isInitialized() {
+    return this.provider !== null;
+  }
+  getProvider() {
+    if (!this.provider) {
+      throw new Error(
+        "[Embeddings] Not initialized. Call initializeEmbeddings() first."
+      );
+    }
+    return this.provider;
+  }
+  getAdapter() {
+    if (!this.adapter) {
+      throw new Error(
+        "[Embeddings] Not initialized. Call initializeEmbeddings() first."
+      );
+    }
+    return this.adapter;
+  }
+  getConfig() {
+    if (!this.config) {
+      throw new Error(
+        "[Embeddings] Not initialized. Call initializeEmbeddings() first."
+      );
+    }
+    return this.config;
+  }
+  getDimensions() {
+    return this.getProvider().dimensions;
+  }
+  getDbDimensions() {
+    return this.getConfig().dbDimensions;
+  }
+  static resolveModelDimensions(model, explicitDimensions) {
+    return explicitDimensions ?? MODEL_DIMENSIONS[model] ?? 384;
+  }
+};
+var embeddingRegistry = new EmbeddingRegistry();
+
+// src/core/embeddings/index.ts
+var _initPromise = null;
+async function initializeEmbeddings() {
+  if (embeddingRegistry.isInitialized()) return;
+  const providerType = env.EMBEDDING_PROVIDER || "openai";
+  const model = env.EMBEDDING_MODEL;
+  const explicitDimensions = env.EMBEDDING_DIMENSIONS;
+  const dbDimensions = env.EMBEDDING_DB_DIMENSIONS ?? 1536;
+  let provider;
+  switch (providerType) {
+    case "huggingface": {
+      const token = env.HUGGINGFACE_ACCESS_TOKEN;
+      if (!token) {
+        throw new Error(
+          "[Embeddings] HUGGINGFACE_ACCESS_TOKEN required for huggingface provider"
+        );
+      }
+      const hfModel = model || "sentence-transformers/all-MiniLM-L6-v2";
+      const dims = EmbeddingRegistry.resolveModelDimensions(
+        hfModel,
+        explicitDimensions
+      );
+      const batchSize = env.EMBEDDING_BATCH_SIZE ?? 32;
+      provider = new HuggingFaceEmbeddingProvider(
+        token,
+        hfModel,
+        dims,
+        batchSize
+      );
+      break;
+    }
+    case "tfidf": {
+      provider = new TFIDFProvider();
+      console.log("[Embeddings] Using TF-IDF fallback (no API required)");
+      break;
+    }
+    case "openai":
+    default: {
+      const apiKey = env.OPENAI_API_KEY;
+      if (!apiKey) {
+        console.warn(
+          "[Embeddings] OPENAI_API_KEY not set, falling back to TF-IDF"
+        );
+        provider = new TFIDFProvider();
+        break;
+      }
+      const oaiModel = model || "text-embedding-3-small";
+      provider = new OpenAIEmbeddingProvider(apiKey, oaiModel);
+      break;
+    }
+  }
+  embeddingRegistry.initialize(provider, {
+    provider: providerType,
+    model,
+    dimensions: provider.dimensions,
+    dbDimensions
+  });
+}
+async function ensureInitialized() {
+  if (embeddingRegistry.isInitialized()) return;
+  if (!_initPromise) {
+    _initPromise = initializeEmbeddings();
+  }
+  await _initPromise;
+}
+async function generateEmbedding(text) {
+  await ensureInitialized();
+  const provider = embeddingRegistry.getProvider();
+  const adapter = embeddingRegistry.getAdapter();
+  const raw = await provider.embedSingle(text);
+  return adapter.adapt(raw);
+}
+
+// src/core/memory.ts
+import { eq, desc, sql } from "drizzle-orm";
+import OpenAI from "openai";
+
+// src/core/security/field-encryption.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var TAG_LENGTH = 16;
+var KEY_LENGTH = 32;
+var CURRENT_KEY_VERSION = 1;
+var _masterKey = null;
+function getMasterKey() {
+  if (_masterKey) return _masterKey;
+  const keyBase64 = env.ENCRYPTION_MASTER_KEY;
+  if (keyBase64) {
+    const key = Buffer.from(keyBase64, "base64");
+    if (key.length !== KEY_LENGTH) {
+      throw new Error(
+        `ENCRYPTION_MASTER_KEY must be ${KEY_LENGTH} bytes (${KEY_LENGTH * 4 / 3} base64 chars). Got ${key.length} bytes.`
+      );
+    }
+    _masterKey = key;
+    return _masterKey;
+  }
+  if (env.NODE_ENV === "production") {
+    throw new Error(
+      `ENCRYPTION_MASTER_KEY is required in production for SOC 2 compliance. Generate one with: node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"`
+    );
+  }
+  console.warn("[field-encryption] No ENCRYPTION_MASTER_KEY set \u2014 using ephemeral key (dev only)");
+  _masterKey = randomBytes(KEY_LENGTH);
+  return _masterKey;
+}
+function encryptField(plaintext) {
+  if (plaintext === null || plaintext === void 0) return null;
+  const key = getMasterKey();
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  const combined = Buffer.concat([
+    Buffer.from([CURRENT_KEY_VERSION]),
+    iv,
+    tag,
+    encrypted
+  ]);
+  return combined.toString("base64");
+}
+function decryptField(encryptedBase64) {
+  if (encryptedBase64 === null || encryptedBase64 === void 0) return null;
+  const combined = Buffer.from(encryptedBase64, "base64");
+  if (combined.length < 1 + IV_LENGTH + TAG_LENGTH + 1) {
+    throw new Error("Encrypted data too short");
+  }
+  const keyVersion = combined[0];
+  if (keyVersion !== CURRENT_KEY_VERSION) {
+    throw new Error(`Unsupported encryption key version: ${keyVersion}`);
+  }
+  const iv = combined.subarray(1, 1 + IV_LENGTH);
+  const tag = combined.subarray(1 + IV_LENGTH, 1 + IV_LENGTH + TAG_LENGTH);
+  const ciphertext = combined.subarray(1 + IV_LENGTH + TAG_LENGTH);
+  const key = getMasterKey();
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+  return decrypted.toString("utf8");
+}
+function isEncryptionAvailable() {
+  try {
+    getMasterKey();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/memory.ts
+var _openai = null;
+function getOpenAI() {
+  if (!_openai) {
+    _openai = new OpenAI({ apiKey: env.OPENAI_API_KEY });
+  }
+  return _openai;
+}
+var openai = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getOpenAI();
+    const value = instance[prop];
+    if (typeof value === "function") {
+      return value.bind(instance);
+    }
+    return value;
+  }
+});
+async function generateEmbedding2(text) {
+  return generateEmbedding(text);
+}
+async function storeMemory(memory) {
+  const embedding = await generateEmbedding2(memory.content);
+  const shouldEncrypt = isEncryptionAvailable();
+  const contentForDb = shouldEncrypt ? encryptField(memory.content) : memory.content;
+  const [stored] = await db.insert(memories).values({
+    ...memory,
+    content: contentForDb,
+    encrypted: shouldEncrypt,
+    embedding,
+    provenance: memory.provenance || `${memory.source || "unknown"}:auto`
+  }).returning();
+  try {
+    await db.execute(sql`
+      UPDATE memories
+      SET search_vector = to_tsvector('english', ${memory.content})
+      WHERE id = ${stored.id}
+    `);
+  } catch {
+  }
+  return { ...stored, content: memory.content };
+}
+async function updateMemory(id, updates) {
+  const setClauses = [];
+  if (updates.content) {
+    const newEmbedding = await generateEmbedding2(updates.content);
+    setClauses.push(sql`content = ${updates.content}`);
+    setClauses.push(sql`embedding = ${JSON.stringify(newEmbedding)}::vector`);
+    setClauses.push(sql`search_vector = to_tsvector('english', ${updates.content})`);
+  }
+  if (updates.type) {
+    setClauses.push(sql`type = ${updates.type}`);
+  }
+  if (updates.importance !== void 0) {
+    setClauses.push(sql`importance = ${updates.importance}`);
+  }
+  if (setClauses.length === 0) return null;
+  const result = await db.execute(sql`
+    UPDATE memories
+    SET ${sql.join(setClauses, sql`, `)}
+    WHERE id = ${id}
+    RETURNING *
+  `);
+  return result[0] || null;
+}
+async function deleteMemory(id) {
+  const result = await db.execute(sql`
+    SELECT * FROM memories WHERE id = ${id}
+  `);
+  const memory = result[0];
+  if (!memory) return false;
+  await db.insert(archivedMemories).values({
+    originalMemoryId: memory.id,
+    userId: memory.user_id,
+    type: memory.type,
+    content: memory.content,
+    reason: "user_request",
+    originalCreatedAt: memory.created_at
+  });
+  await db.execute(sql`DELETE FROM memories WHERE id = ${id}`);
+  return true;
+}
+async function exportMemories(userId, format = "markdown") {
+  const mems = await db.select().from(memories).where(userId ? eq(memories.userId, userId) : void 0).orderBy(desc(memories.createdAt));
+  for (const m of mems) {
+    if (m.encrypted) {
+      try {
+        m.content = decryptField(m.content) ?? m.content;
+      } catch {
+      }
+    }
+  }
+  if (format === "json") {
+    return JSON.stringify(
+      mems.map((m) => ({
+        id: m.id,
+        type: m.type,
+        content: m.content,
+        importance: m.importance,
+        source: m.source,
+        provenance: m.provenance,
+        createdAt: m.createdAt
+      })),
+      null,
+      2
+    );
+  }
+  const lines = [
+    "# Memories Export",
+    `Exported: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `Total: ${mems.length} memories`,
+    ""
+  ];
+  for (const m of mems) {
+    lines.push(`## [${m.type}] (Importance: ${m.importance}/10)`);
+    lines.push(m.content);
+    lines.push(`_Source: ${m.source || "unknown"} | Created: ${m.createdAt.toISOString()}_`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function searchMemories(query, userId, limit = 5) {
+  const queryEmbedding = await generateEmbedding2(query);
+  const results = await db.execute(sql`
+    SELECT
+      id, user_id, type, content, importance, source, provenance, metadata,
+      last_accessed, created_at,
+      1 - (embedding <=> ${JSON.stringify(queryEmbedding)}::vector) as similarity
+    FROM memories
+    ${userId ? sql`WHERE user_id = ${userId}` : sql``}
+    ORDER BY embedding <=> ${JSON.stringify(queryEmbedding)}::vector
+    LIMIT ${limit}
+  `);
+  const rows = results;
+  const memoryIds = rows.map((r) => r.id);
+  if (memoryIds.length > 0) {
+    await db.execute(sql`
+      UPDATE memories
+      SET last_accessed = NOW()
+      WHERE id = ANY(${memoryIds}::uuid[])
+    `);
+  }
+  for (const row of rows) {
+    if (row.encrypted) {
+      try {
+        row.content = decryptField(row.content) ?? row.content;
+      } catch {
+      }
+    }
+  }
+  return rows;
+}
+async function getMemoryById(id) {
+  const result = await db.execute(sql`
+    SELECT * FROM memories WHERE id = ${id}
+  `);
+  const row = result[0] || null;
+  if (row && row.encrypted) {
+    try {
+      row.content = decryptField(row.content) ?? row.content;
+    } catch {
+    }
+  }
+  return row;
+}
+async function extractMemories(content, userId) {
+  const extractionPrompt = `Analyze this text and extract any important facts that should be remembered about the user or their preferences. Return a JSON array of objects with "content" (the fact), "type" (semantic/episodic/procedural), and "importance" (1-10).
+
+Text: "${content}"
+
+Return only the JSON array, no other text. If no memorable facts, return [].`;
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: extractionPrompt }],
+      response_format: { type: "json_object" }
+    });
+    const extracted = JSON.parse(
+      response.choices[0].message.content || '{"memories":[]}'
+    );
+    const memoriesToStore = extracted.memories || extracted || [];
+    const storedMemories = [];
+    for (const mem of memoriesToStore) {
+      if (mem.content && mem.content.length > 5) {
+        const stored = await storeMemory({
+          userId,
+          content: mem.content,
+          type: mem.type || "semantic",
+          importance: mem.importance || 5,
+          source: "conversation",
+          provenance: "extraction:auto"
+        });
+        storedMemories.push(stored);
+      }
+    }
+    return storedMemories;
+  } catch (error) {
+    console.error("Error extracting memories:", error);
+    return [];
+  }
+}
+async function buildMemoryContext(query, userId, conversationHistory) {
+  const anyAdvancedEnabled = env.HYDE_ENABLED || env.RERANK_ENABLED || env.MULTISTEP_RAG_ENABLED || env.RETRIEVAL_CACHE_ENABLED || env.CONTEXTUAL_QUERY_ENABLED;
+  if (anyAdvancedEnabled) {
+    try {
+      const { enhancedRetrieve } = await import("./enhanced-retrieval-OGHT6TS5.js");
+      const result = await enhancedRetrieve(query, { userId, limit: 5, conversationHistory });
+      if (result.results.length === 0) {
+        return "";
+      }
+      const memoryStrings2 = result.results.map((m) => {
+        const provenance = m.provenance ? ` [${m.provenance}]` : "";
+        const score = m.rerankScore != null ? `rerank: ${m.rerankScore}/10` : `relevance: ${((m.similarity || 0) * 100).toFixed(0)}%`;
+        return `- [${m.type}] ${m.content} (${score})${provenance}`;
+      });
+      return `
+
+Relevant memories about the user:
+${memoryStrings2.join("\n")}`;
+    } catch {
+    }
+  }
+  const relevantMemories = await searchMemories(query, userId, 5);
+  if (relevantMemories.length === 0) {
+    return "";
+  }
+  const memoryStrings = relevantMemories.map(
+    (m) => {
+      const provenance = m.provenance ? ` [${m.provenance}]` : "";
+      return `- [${m.type}] ${m.content} (relevance: ${(m.similarity * 100).toFixed(0)}%)${provenance}`;
+    }
+  );
+  return `
+
+Relevant memories about the user:
+${memoryStrings.join("\n")}`;
+}
+
+export {
+  TFIDFProvider,
+  decryptField,
+  initializeEmbeddings,
+  generateEmbedding2 as generateEmbedding,
+  storeMemory,
+  updateMemory,
+  deleteMemory,
+  exportMemories,
+  searchMemories,
+  getMemoryById,
+  extractMemories,
+  buildMemoryContext
+};
+//# sourceMappingURL=chunk-6UZPE35A.js.map