@workglow/storage 0.0.115 → 0.0.117

package/dist/node.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/tabular/BaseTabularStorage.ts
 import {
   createServiceToken,
@@ -1138,6 +1141,102 @@ function resolveRepositoryFromRegistry(id, format, registry) {
   return repo;
 }
 registerInputResolver("storage:tabular", resolveRepositoryFromRegistry);
+// src/util/traced.ts
+import { getTelemetryProvider, SpanStatusCode } from "@workglow/util";
+async function traced(spanName, storageName, fn) {
+  const telemetry = getTelemetryProvider();
+  if (!telemetry.isEnabled)
+    return fn();
+  const span = telemetry.startSpan(spanName, {
+    attributes: { "workglow.storage.name": storageName }
+  });
+  try {
+    const result = await fn();
+    span.setStatus(SpanStatusCode.OK);
+    return result;
+  } catch (err) {
+    span.setStatus(SpanStatusCode.ERROR, err instanceof Error ? err.message : String(err));
+    throw err;
+  } finally {
+    span.end();
+  }
+}
+
+// src/tabular/TelemetryTabularStorage.ts
+class TelemetryTabularStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  put(value) {
+    return traced("workglow.storage.tabular.put", this.storageName, () => this.inner.put(value));
+  }
+  putBulk(values) {
+    return traced("workglow.storage.tabular.putBulk", this.storageName, () => this.inner.putBulk(values));
+  }
+  get(key) {
+    return traced("workglow.storage.tabular.get", this.storageName, () => this.inner.get(key));
+  }
+  delete(key) {
+    return traced("workglow.storage.tabular.delete", this.storageName, () => this.inner.delete(key));
+  }
+  getAll(options) {
+    return traced("workglow.storage.tabular.getAll", this.storageName, () => this.inner.getAll(options));
+  }
+  deleteAll() {
+    return traced("workglow.storage.tabular.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  size() {
+    return traced("workglow.storage.tabular.size", this.storageName, () => this.inner.size());
+  }
+  deleteSearch(criteria) {
+    return traced("workglow.storage.tabular.deleteSearch", this.storageName, () => this.inner.deleteSearch(criteria));
+  }
+  getBulk(offset, limit) {
+    return traced("workglow.storage.tabular.getBulk", this.storageName, () => this.inner.getBulk(offset, limit));
+  }
+  query(criteria, options) {
+    return traced("workglow.storage.tabular.query", this.storageName, () => this.inner.query(criteria, options));
+  }
+  records(pageSize) {
+    return this.inner.records(pageSize);
+  }
+  pages(pageSize) {
+    return this.inner.pages(pageSize);
+  }
+  subscribeToChanges(callback, options) {
+    return this.inner.subscribeToChanges(callback, options);
+  }
+  setupDatabase() {
+    return this.inner.setupDatabase();
+  }
+  destroy() {
+    return this.inner.destroy();
+  }
+  [Symbol.dispose]() {
+    return this.inner[Symbol.dispose]();
+  }
+  [Symbol.asyncDispose]() {
+    return this.inner[Symbol.asyncDispose]();
+  }
+  on(name, fn) {
+    this.inner.on(name, fn);
+  }
+  off(name, fn) {
+    this.inner.off(name, fn);
+  }
+  emit(name, ...args) {
+    this.inner.emit(name, ...args);
+  }
+  once(name, fn) {
+    this.inner.once(name, fn);
+  }
+  waitOn(name) {
+    return this.inner.waitOn(name);
+  }
+}
 // src/kv/IKvStorage.ts
 var DefaultKeyValueSchema = {
   type: "object",
@@ -1269,6 +1368,54 @@ class InMemoryKvStorage extends KvViaTabularStorage {
     this.tabularRepository = new InMemoryTabularStorage(DefaultKeyValueSchema, DefaultKeyValueKey);
   }
 }
+// src/kv/TelemetryKvStorage.ts
+class TelemetryKvStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  put(key, value) {
+    return traced("workglow.storage.kv.put", this.storageName, () => this.inner.put(key, value));
+  }
+  putBulk(items) {
+    return traced("workglow.storage.kv.putBulk", this.storageName, () => this.inner.putBulk(items));
+  }
+  get(key) {
+    return traced("workglow.storage.kv.get", this.storageName, () => this.inner.get(key));
+  }
+  delete(key) {
+    return traced("workglow.storage.kv.delete", this.storageName, () => this.inner.delete(key));
+  }
+  getAll() {
+    return traced("workglow.storage.kv.getAll", this.storageName, () => this.inner.getAll());
+  }
+  deleteAll() {
+    return traced("workglow.storage.kv.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  size() {
+    return traced("workglow.storage.kv.size", this.storageName, () => this.inner.size());
+  }
+  getObjectAsIdString(object) {
+    return this.inner.getObjectAsIdString(object);
+  }
+  on(name, fn) {
+    this.inner.on(name, fn);
+  }
+  off(name, fn) {
+    this.inner.off(name, fn);
+  }
+  emit(name, ...args) {
+    this.inner.emit(name, ...args);
+  }
+  once(name, fn) {
+    this.inner.once(name, fn);
+  }
+  waitOn(name) {
+    return this.inner.waitOn(name);
+  }
+}
 // src/queue/InMemoryQueueStorage.ts
 import {
   createServiceToken as createServiceToken9,
@@ -1480,6 +1627,60 @@ class InMemoryQueueStorage {
     return this.events.subscribe("change", filteredCallback);
   }
 }
+// src/queue/TelemetryQueueStorage.ts
+class TelemetryQueueStorage {
+  storageName;
+  inner;
+  constructor(storageName, inner) {
+    this.storageName = storageName;
+    this.inner = inner;
+  }
+  add(job) {
+    return traced("workglow.storage.queue.add", this.storageName, () => this.inner.add(job));
+  }
+  get(id) {
+    return traced("workglow.storage.queue.get", this.storageName, () => this.inner.get(id));
+  }
+  next(workerId) {
+    return traced("workglow.storage.queue.next", this.storageName, () => this.inner.next(workerId));
+  }
+  peek(status, num) {
+    return traced("workglow.storage.queue.peek", this.storageName, () => this.inner.peek(status, num));
+  }
+  size(status) {
+    return traced("workglow.storage.queue.size", this.storageName, () => this.inner.size(status));
+  }
+  complete(job) {
+    return traced("workglow.storage.queue.complete", this.storageName, () => this.inner.complete(job));
+  }
+  deleteAll() {
+    return traced("workglow.storage.queue.deleteAll", this.storageName, () => this.inner.deleteAll());
+  }
+  outputForInput(input) {
+    return traced("workglow.storage.queue.outputForInput", this.storageName, () => this.inner.outputForInput(input));
+  }
+  abort(id) {
+    return traced("workglow.storage.queue.abort", this.storageName, () => this.inner.abort(id));
+  }
+  getByRunId(runId) {
+    return traced("workglow.storage.queue.getByRunId", this.storageName, () => this.inner.getByRunId(runId));
+  }
+  saveProgress(id, progress, message, details) {
+    return traced("workglow.storage.queue.saveProgress", this.storageName, () => this.inner.saveProgress(id, progress, message, details));
+  }
+  delete(id) {
+    return traced("workglow.storage.queue.delete", this.storageName, () => this.inner.delete(id));
+  }
+  deleteJobsByStatusAndAge(status, olderThanMs) {
+    return traced("workglow.storage.queue.deleteJobsByStatusAndAge", this.storageName, () => this.inner.deleteJobsByStatusAndAge(status, olderThanMs));
+  }
+  setupDatabase() {
+    return this.inner.setupDatabase();
+  }
+  subscribeToChanges(callback, options) {
+    return this.inner.subscribeToChanges(callback, options);
+  }
+}
 // src/queue-limiter/InMemoryRateLimiterStorage.ts
 import { createServiceToken as createServiceToken10, sleep as sleep2 } from "@workglow/util";
 var IN_MEMORY_RATE_LIMITER_STORAGE = createServiceToken10("ratelimiter.storage.inMemory");
@@ -1933,6 +2134,26 @@ class InMemoryVectorStorage extends InMemoryTabularStorage {
     return topResults;
   }
 }
+// src/vector/TelemetryVectorStorage.ts
+class TelemetryVectorStorage extends TelemetryTabularStorage {
+  vectorInner;
+  constructor(storageName, inner) {
+    super(storageName, inner);
+    this.vectorInner = inner;
+  }
+  getVectorDimensions() {
+    return this.vectorInner.getVectorDimensions();
+  }
+  similaritySearch(query, options) {
+    return traced("workglow.storage.vector.similaritySearch", this.storageName, () => this.vectorInner.similaritySearch(query, options));
+  }
+  hybridSearch(query, options) {
+    if (!this.vectorInner.hybridSearch) {
+      throw new Error("hybridSearch is not supported by the underlying storage implementation");
+    }
+    return traced("workglow.storage.vector.hybridSearch", this.storageName, () => this.vectorInner.hybridSearch(query, options));
+  }
+}
 // src/credentials/EncryptedKvCredentialStore.ts
 import { decrypt, encrypt } from "@workglow/util";
 
@@ -2912,6 +3133,9 @@ var Database = Sqlite.Database;
 
 class SqliteTabularStorage extends BaseSqlTabularStorage {
   db;
+  get database() {
+    return this.db;
+  }
   constructor(dbOrPath, table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
     super(table, schema, primaryKeyNames, indexes, clientProvidedKeys);
     if (typeof dbOrPath === "string") {
@@ -5896,6 +6120,390 @@ class SqliteVectorStorage extends SqliteTabularStorage {
     return topResults;
   }
 }
+// src/vector/SqliteAiVectorStorage.ts
+import { cosineSimilarity as cosineSimilarity4 } from "@workglow/util";
+var VECTOR_TYPE_MAP = {
+  Float32Array: "f32",
+  Float64Array: "f32",
+  Int8Array: "i8",
+  Uint8Array: "u8",
+  Int16Array: "f16"
+};
+function getVectorTypeSuffix(VectorType) {
+  return VECTOR_TYPE_MAP[VectorType.name] || "f32";
+}
+function getVectorTypeOption(VectorType) {
+  const typeMap = {
+    Float32Array: "FLOAT32",
+    Float64Array: "FLOAT32",
+    Int8Array: "INT8",
+    Uint8Array: "UINT8",
+    Int16Array: "FLOAT16"
+  };
+  return typeMap[VectorType.name] || "FLOAT32";
+}
+function matchesFilter3(metadata, filter) {
+  for (const [key, value] of Object.entries(filter)) {
+    if (metadata[key] !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function escapeIdentifier(name) {
+  return "`" + name.replace(/`/g, "``") + "`";
+}
+
+class SqliteAiVectorStorage extends SqliteTabularStorage {
+  vectorDimensions;
+  VectorType;
+  vectorPropertyName;
+  metadataPropertyName;
+  vectorTypeSuffix;
+  extensionLoaded = false;
+  constructor(dbOrPath, table = "vectors", schema, primaryKeyNames, indexes = [], dimensions, VectorType = Float32Array) {
+    super(dbOrPath, table, schema, primaryKeyNames, indexes);
+    this.vectorDimensions = dimensions;
+    this.VectorType = VectorType;
+    this.vectorTypeSuffix = getVectorTypeSuffix(VectorType);
+    const vectorProp = getVectorProperty(schema);
+    if (!vectorProp) {
+      throw new Error("Schema must have a property with type array and format TypedArray");
+    }
+    this.vectorPropertyName = vectorProp;
+    this.metadataPropertyName = getMetadataProperty(schema);
+  }
+  getVectorDimensions() {
+    return this.vectorDimensions;
+  }
+  async setupDatabase() {
+    await super.setupDatabase();
+    if (!this.extensionLoaded) {
+      try {
+        const { getExtensionPath } = await import("@sqliteai/sqlite-vector");
+        this.database.loadExtension(getExtensionPath());
+        this.extensionLoaded = true;
+      } catch {
+        try {
+          this.database.exec("SELECT vector_version()");
+          this.extensionLoaded = true;
+        } catch {}
+      }
+    }
+    if (this.extensionLoaded) {
+      const vectorCol = String(this.vectorPropertyName);
+      const vectorType = getVectorTypeOption(this.VectorType);
+      try {
+        this.database.prepare("SELECT vector_init(?, ?, ?)").run(this.table, vectorCol, `dimension=${this.vectorDimensions},type=${vectorType},distance=COSINE`);
+      } catch {}
+    }
+  }
+  encodeVectorJson(vector) {
+    return `[${Array.from(vector).join(",")}]`;
+  }
+  decodeVector(raw) {
+    if (raw instanceof Uint8Array || typeof Buffer !== "undefined" && raw instanceof Buffer) {
+      const view = raw instanceof Uint8Array ? raw : new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+      if (this.VectorType === Float32Array || this.VectorType.name === "Float32Array") {
+        return new Float32Array(view.buffer, view.byteOffset, this.vectorDimensions);
+      }
+      const f32 = new Float32Array(view.buffer, view.byteOffset, this.vectorDimensions);
+      return new this.VectorType(Array.from(f32));
+    }
+    if (typeof raw === "string") {
+      const array = JSON.parse(raw);
+      return new this.VectorType(array);
+    }
+    if (Array.isArray(raw)) {
+      return new this.VectorType(raw);
+    }
+    throw new Error(`Cannot decode vector from type: ${typeof raw}`);
+  }
+  jsToSqlValue(column, value) {
+    if (column === String(this.vectorPropertyName) && value != null) {
+      const vector = value;
+      return this.encodeVectorJson(vector);
+    }
+    return super.jsToSqlValue(column, value);
+  }
+  sqlToJsValue(column, value) {
+    if (column === String(this.vectorPropertyName) && value != null) {
+      return this.decodeVector(value);
+    }
+    return super.sqlToJsValue(column, value);
+  }
+  mapTypeToSQL(typeDef) {
+    if (typeof typeDef !== "boolean" && typeDef.type === "array") {
+      const format = typeDef.format;
+      if (format === "TypedArray" || format?.startsWith("TypedArray:")) {
+        return "BLOB";
+      }
+    }
+    return super.mapTypeToSQL(typeDef);
+  }
+  async put(entity) {
+    if (!this.extensionLoaded) {
+      return super.put(entity);
+    }
+    const db = this.database;
+    const vectorCol = String(this.vectorPropertyName);
+    let entityToInsert = entity;
+    if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName) {
+      const keyName = String(this.autoGeneratedKeyName);
+      const clientProvidedValue = entity[keyName];
+      const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
+      const clientProvidedKeys = this.clientProvidedKeys;
+      const autoGeneratedKeyStrategy = this.autoGeneratedKeyStrategy;
+      if (autoGeneratedKeyStrategy === "uuid" && !hasClientValue && clientProvidedKeys !== "always") {
+        const generatedValue = this.generateKeyValue(keyName, "uuid");
+        entityToInsert = { ...entity, [keyName]: generatedValue };
+      }
+    }
+    const allColumns = [];
+    const placeholders = [];
+    const params = [];
+    const pkColumns = this.primaryKeyColumns();
+    for (const col of pkColumns) {
+      const autoGeneratedKeyStrategy = this.autoGeneratedKeyStrategy;
+      const isAutoKey = this.isAutoGeneratedKey(col);
+      if (isAutoKey && autoGeneratedKeyStrategy === "autoincrement") {
+        const clientProvidedKeys = this.clientProvidedKeys;
+        const clientValue = entityToInsert[col];
+        if (clientProvidedKeys === "if-missing" && clientValue != null) {
+          allColumns.push(col);
+          placeholders.push("?");
+          params.push(this.jsToSqlValue(col, clientValue));
+        }
+        continue;
+      }
+      allColumns.push(col);
+      placeholders.push("?");
+      params.push(this.jsToSqlValue(col, entityToInsert[col]));
+    }
+    const valueColumns = this.valueColumns();
+    for (const col of valueColumns) {
+      allColumns.push(col);
+      const value = entityToInsert[col];
+      if (col === vectorCol && value != null) {
+        placeholders.push(`vector_as_${this.vectorTypeSuffix}(?)`);
+        params.push(this.encodeVectorJson(value));
+      } else {
+        placeholders.push("?");
+        params.push(this.jsToSqlValue(col, value));
+      }
+    }
+    const columnList = allColumns.map((c) => `\`${c}\``).join(", ");
+    const placeholderList = placeholders.join(", ");
+    const sql = `
+      INSERT OR REPLACE INTO ${escapeIdentifier(this.table)} (${columnList})
+      VALUES (${placeholderList})
+      RETURNING *
+    `;
+    for (let i = 0;i < params.length; i++) {
+      if (params[i] === undefined) {
+        params[i] = null;
+      } else if (params[i] !== null && typeof params[i] === "object") {
+        const p = params[i];
+        if (!(p instanceof Uint8Array) && (typeof Buffer === "undefined" || !(p instanceof Buffer))) {
+          params[i] = JSON.stringify(p);
+        }
+      }
+    }
+    const stmt = db.prepare(sql);
+    const updatedEntity = stmt.get(...params);
+    const updatedRecord = updatedEntity;
+    for (const k in this.schema.properties) {
+      updatedRecord[k] = this.sqlToJsValue(k, updatedRecord[k]);
+    }
+    this.events.emit("put", updatedEntity);
+    return updatedEntity;
+  }
+  async similaritySearch(query, options = {}) {
+    if (!this.extensionLoaded) {
+      return this.searchFallback(query, options);
+    }
+    const { topK = 10, filter, scoreThreshold = 0 } = options;
+    const db = this.database;
+    const tableName = this.table;
+    const vectorCol = String(this.vectorPropertyName);
+    const metadataCol = this.metadataPropertyName ? String(this.metadataPropertyName) : null;
+    try {
+      const queryJson = this.encodeVectorJson(query);
+      const queryBlob = db.prepare(`SELECT vector_as_${this.vectorTypeSuffix}(?) as v`).get(queryJson);
+      if (filter && Object.keys(filter).length > 0) {
+        const sql2 = `
+          SELECT t.*, v.distance
+          FROM ${escapeIdentifier(tableName)} AS t
+          JOIN vector_full_scan(?, ?, ?) AS v
+          ON t.rowid = v.rowid
+          ORDER BY v.distance ASC
+        `;
+        const stmt2 = db.prepare(sql2);
+        const rows2 = stmt2.all(tableName, vectorCol, queryBlob.v);
+        const results2 = [];
+        for (const row of rows2) {
+          const score = 1 - row.distance;
+          if (score < scoreThreshold) {
+            continue;
+          }
+          const entity = { ...row };
+          delete entity.distance;
+          for (const k in this.schema.properties) {
+            entity[k] = this.sqlToJsValue(k, entity[k]);
+          }
+          const metadata = metadataCol ? entity[metadataCol] : {};
+          if (filter && !matchesFilter3(metadata, filter)) {
+            continue;
+          }
+          results2.push({ ...entity, score });
+          if (results2.length >= topK) {
+            break;
+          }
+        }
+        results2.sort((a, b) => b.score - a.score);
+        return results2.slice(0, topK);
+      }
+      const sql = `
+        SELECT t.*, v.distance
+        FROM ${escapeIdentifier(tableName)} AS t
+        JOIN vector_full_scan(?, ?, ?, ?) AS v
+        ON t.rowid = v.rowid
+        ORDER BY v.distance ASC
+      `;
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(tableName, vectorCol, queryBlob.v, topK);
+      const results = [];
+      for (const row of rows) {
+        const score = 1 - row.distance;
+        if (score < scoreThreshold) {
+          continue;
+        }
+        const entity = { ...row };
+        delete entity.distance;
+        for (const k in this.schema.properties) {
+          entity[k] = this.sqlToJsValue(k, entity[k]);
+        }
+        results.push({ ...entity, score });
+      }
+      return results;
+    } catch (error) {
+      console.warn("sqlite-vector query failed, falling back to in-memory search:", error);
+      return this.searchFallback(query, options);
+    }
+  }
+  async hybridSearch(query, options) {
+    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
+    if (!textQuery || textQuery.trim().length === 0) {
+      return this.similaritySearch(query, { topK, filter, scoreThreshold });
+    }
+    if (!this.extensionLoaded) {
+      return this.hybridSearchFallback(query, options);
+    }
+    const db = this.database;
+    const tableName = this.table;
+    const vectorCol = String(this.vectorPropertyName);
+    const metadataCol = this.metadataPropertyName ? String(this.metadataPropertyName) : null;
+    try {
+      const queryJson = this.encodeVectorJson(query);
+      const queryBlob = db.prepare(`SELECT vector_as_${this.vectorTypeSuffix}(?) as v`).get(queryJson);
+      const sql = `
+        SELECT t.*, v.distance
+        FROM ${escapeIdentifier(tableName)} AS t
+        JOIN vector_full_scan(?, ?, ?) AS v
+        ON t.rowid = v.rowid
+        ORDER BY v.distance ASC
+      `;
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(tableName, vectorCol, queryBlob.v);
+      const queryLower = textQuery.toLowerCase();
+      const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
+      const results = [];
+      for (const row of rows) {
+        const vectorScore = 1 - row.distance;
+        const entity = { ...row };
+        delete entity.distance;
+        for (const k in this.schema.properties) {
+          entity[k] = this.sqlToJsValue(k, entity[k]);
+        }
+        const metadata = metadataCol ? entity[metadataCol] : {};
+        if (filter && !matchesFilter3(metadata, filter)) {
+          continue;
+        }
+        const metadataText = JSON.stringify(metadata).toLowerCase();
+        let textScore = 0;
+        if (queryWords.length > 0) {
+          let matches = 0;
+          for (const word of queryWords) {
+            if (metadataText.includes(word)) {
+              matches++;
+            }
+          }
+          textScore = matches / queryWords.length;
+        }
+        const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
+        if (combinedScore < scoreThreshold) {
+          continue;
+        }
+        results.push({ ...entity, score: combinedScore });
+      }
+      results.sort((a, b) => b.score - a.score);
+      return results.slice(0, topK);
+    } catch (error) {
+      console.warn("sqlite-vector hybrid query failed, falling back to in-memory search:", error);
+      return this.hybridSearchFallback(query, options);
+    }
+  }
+  async searchFallback(query, options) {
+    const { topK = 10, filter, scoreThreshold = 0 } = options;
+    const allRows = await this.getAll() || [];
+    const results = [];
+    for (const row of allRows) {
+      const vector = row[this.vectorPropertyName];
+      const metadata = this.metadataPropertyName ? row[this.metadataPropertyName] : {};
+      if (filter && !matchesFilter3(metadata, filter)) {
+        continue;
+      }
+      const score = cosineSimilarity4(query, vector);
+      if (score >= scoreThreshold) {
+        results.push({ ...row, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  async hybridSearchFallback(query, options) {
+    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
+    const allRows = await this.getAll() || [];
+    const results = [];
+    const queryLower = textQuery.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
+    for (const row of allRows) {
+      const vector = row[this.vectorPropertyName];
+      const metadata = this.metadataPropertyName ? row[this.metadataPropertyName] : {};
+      if (filter && !matchesFilter3(metadata, filter)) {
+        continue;
+      }
+      const vectorScore = cosineSimilarity4(query, vector);
+      const metadataText = JSON.stringify(metadata).toLowerCase();
+      let textScore = 0;
+      if (queryWords.length > 0) {
+        let matches = 0;
+        for (const word of queryWords) {
+          if (metadataText.includes(word)) {
+            matches++;
+          }
+        }
+        textScore = matches / queryWords.length;
+      }
+      const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
+      if (combinedScore >= scoreThreshold) {
+        results.push({ ...row, score: combinedScore });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+}
 // src/kv/IndexedDbKvStorage.ts
 import { createServiceToken as createServiceToken28 } from "@workglow/util";
 
@@ -7484,9 +8092,9 @@ class IndexedDbQueueStorage {
   }
 }
 // src/vector/IndexedDbVectorStorage.ts
-import { cosineSimilarity as cosineSimilarity4, createServiceToken as createServiceToken31 } from "@workglow/util";
+import { cosineSimilarity as cosineSimilarity5, createServiceToken as createServiceToken31 } from "@workglow/util";
 var IDB_VECTOR_REPOSITORY = createServiceToken31("storage.vectorRepository.indexedDb");
-function matchesFilter3(metadata, filter) {
+function matchesFilter4(metadata, filter) {
   for (const [key, value] of Object.entries(filter)) {
     if (metadata[key] !== value) {
       return false;
@@ -7536,10 +8144,10 @@ class IndexedDbVectorStorage extends IndexedDbTabularStorage {
     for (const entity of allEntities) {
       const vector = entity[this.vectorPropertyName];
       const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
-      if (filter && !matchesFilter3(metadata, filter)) {
+      if (filter && !matchesFilter4(metadata, filter)) {
         continue;
       }
-      const score = cosineSimilarity4(query, vector);
+      const score = cosineSimilarity5(query, vector);
       if (score < scoreThreshold) {
         continue;
       }
@@ -7562,10 +8170,10 @@ class IndexedDbVectorStorage extends IndexedDbTabularStorage {
     for (const entity of allEntities) {
       const vector = entity[this.vectorPropertyName];
       const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
-      if (filter && !matchesFilter3(metadata, filter)) {
+      if (filter && !matchesFilter4(metadata, filter)) {
         continue;
       }
-      const vectorScore = cosineSimilarity4(query, vector);
+      const vectorScore = cosineSimilarity5(query, vector);
       const metadataText = Object.values(metadata).join(" ").toLowerCase();
       const textScore = textRelevance2(metadataText, textQuery);
       const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
@@ -7583,6 +8191,7 @@ class IndexedDbVectorStorage extends IndexedDbTabularStorage {
   }
 }
 export {
+  traced,
   registerTabularRepository,
   isSearchCondition,
   getVectorProperty,
@@ -7591,6 +8200,10 @@ export {
   getGlobalTabularRepositories,
   ensureIndexedDbTable,
   dropIndexedDbTable,
+  TelemetryVectorStorage,
+  TelemetryTabularStorage,
+  TelemetryQueueStorage,
+  TelemetryKvStorage,
   TABULAR_REPOSITORY,
   TABULAR_REPOSITORIES,
   SupabaseTabularStorage,
@@ -7608,6 +8221,7 @@ export {
   SqliteRateLimiterStorage,
   SqliteQueueStorage,
   SqliteKvStorage,
+  SqliteAiVectorStorage,
   SUPABASE_TABULAR_REPOSITORY,
   SUPABASE_RATE_LIMITER_STORAGE,
   SUPABASE_QUEUE_STORAGE,
@@ -7668,4 +8282,4 @@ export {
   BaseTabularStorage
 };
 
-//# debugId=10EEBA1FB4F879DB64756E2164756E21
+//# debugId=5B35BE32DD643BE064756E2164756E21