@mastra/libsql 1.16.0 → 1.17.0-alpha.1

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createClient } from '@libsql/client';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createVectorErrorId, AgentsStorage, AGENTS_SCHEMA, TABLE_AGENTS, AGENT_VERSIONS_SCHEMA, TABLE_AGENT_VERSIONS, createStorageErrorId, normalizePerPage, calculatePagination, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS, TABLE_SCHEMAS, BlobStore, TABLE_SKILL_BLOBS, SKILL_BLOBS_SCHEMA, ChannelsStorage, TABLE_CHANNEL_INSTALLATIONS, TABLE_CHANNEL_CONFIG, DatasetsStorage, DATASETS_SCHEMA, TABLE_DATASETS, DATASET_ITEMS_SCHEMA, TABLE_DATASET_ITEMS, DATASET_VERSIONS_SCHEMA, TABLE_DATASET_VERSIONS, TABLE_EXPERIMENTS, TABLE_EXPERIMENT_RESULTS, ensureDate, safelyParseJSON, hasErrorCode, ExperimentsStorage, EXPERIMENTS_SCHEMA, EXPERIMENT_RESULTS_SCHEMA, FavoritesStorage, FAVORITES_SCHEMA, TABLE_FAVORITES, TABLE_SKILLS, HarnessStorage, TABLE_HARNESS_SESSIONS, MCPClientsStorage, MCP_CLIENTS_SCHEMA, TABLE_MCP_CLIENTS, MCP_CLIENT_VERSIONS_SCHEMA, TABLE_MCP_CLIENT_VERSIONS, MCPServersStorage, MCP_SERVERS_SCHEMA, TABLE_MCP_SERVERS, MCP_SERVER_VERSIONS_SCHEMA, TABLE_MCP_SERVER_VERSIONS, MemoryStorage, TABLE_THREADS, TABLE_RESOURCES, TABLE_MESSAGES, OBSERVATIONAL_MEMORY_TABLE_SCHEMA, NotificationsStorage, TABLE_NOTIFICATIONS, ObservabilityStorage, TABLE_SPANS, SPAN_SCHEMA, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, PROMPT_BLOCKS_SCHEMA, TABLE_PROMPT_BLOCKS, PROMPT_BLOCK_VERSIONS_SCHEMA, TABLE_PROMPT_BLOCK_VERSIONS, SchedulesStorage, TABLE_SCHEDULE_TRIGGERS, TABLE_SCHEDULES, ScorerDefinitionsStorage, SCORER_DEFINITIONS_SCHEMA, TABLE_SCORER_DEFINITIONS, SCORER_DEFINITION_VERSIONS_SCHEMA, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, TABLE_SCORERS, SCORERS_SCHEMA, transformScoreRow, SkillsStorage, SKILLS_SCHEMA, SKILL_VERSIONS_SCHEMA, TABLE_SKILL_VERSIONS, ThreadStateStorage, TABLE_THREAD_STATE, THREAD_STATE_SCHEMA, ToolProviderConnectionsStorage, TOOL_PROVIDER_CONNECTIONS_SCHEMA, TABLE_TOOL_PROVIDER_CONNECTIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, WORKSPACES_SCHEMA, TABLE_WORKSPACES, WORKSPACE_VERSIONS_SCHEMA, TABLE_WORKSPACE_VERSIONS, MastraCompositeStore, getSqlType, parseDuration, normalizeScheduleTarget, TraceStatus, mergeWorkflowStepResult } from '@mastra/core/storage';
+import { createVectorErrorId, AgentsStorage, AGENTS_SCHEMA, TABLE_AGENTS, AGENT_VERSIONS_SCHEMA, TABLE_AGENT_VERSIONS, createStorageErrorId, normalizePerPage, calculatePagination, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS, TABLE_SCHEMAS, BlobStore, TABLE_SKILL_BLOBS, SKILL_BLOBS_SCHEMA, ChannelsStorage, TABLE_CHANNEL_INSTALLATIONS, TABLE_CHANNEL_CONFIG, DatasetsStorage, DATASETS_SCHEMA, TABLE_DATASETS, DATASET_ITEMS_SCHEMA, TABLE_DATASET_ITEMS, DATASET_VERSIONS_SCHEMA, TABLE_DATASET_VERSIONS, TABLE_EXPERIMENTS, TABLE_EXPERIMENT_RESULTS, ensureDate, safelyParseJSON, hasErrorCode, ExperimentsStorage, EXPERIMENTS_SCHEMA, EXPERIMENT_RESULTS_SCHEMA, FavoritesStorage, FAVORITES_SCHEMA, TABLE_FAVORITES, TABLE_SKILLS, HarnessStorage, TABLE_HARNESS_SESSIONS, MCPClientsStorage, MCP_CLIENTS_SCHEMA, TABLE_MCP_CLIENTS, MCP_CLIENT_VERSIONS_SCHEMA, TABLE_MCP_CLIENT_VERSIONS, MCPServersStorage, MCP_SERVERS_SCHEMA, TABLE_MCP_SERVERS, MCP_SERVER_VERSIONS_SCHEMA, TABLE_MCP_SERVER_VERSIONS, MemoryStorage, TABLE_THREADS, TABLE_RESOURCES, TABLE_MESSAGES, OBSERVATIONAL_MEMORY_TABLE_SCHEMA, NotificationsStorage, TABLE_NOTIFICATIONS, ObservabilityStorage, TABLE_SPANS, SPAN_SCHEMA, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, PROMPT_BLOCKS_SCHEMA, TABLE_PROMPT_BLOCKS, PROMPT_BLOCK_VERSIONS_SCHEMA, TABLE_PROMPT_BLOCK_VERSIONS, SchedulesStorage, TABLE_SCHEDULE_TRIGGERS, TABLE_SCHEDULES, ScorerDefinitionsStorage, SCORER_DEFINITIONS_SCHEMA, TABLE_SCORER_DEFINITIONS, SCORER_DEFINITION_VERSIONS_SCHEMA, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, TABLE_SCORERS, SCORERS_SCHEMA, transformScoreRow, SkillsStorage, SKILLS_SCHEMA, SKILL_VERSIONS_SCHEMA, TABLE_SKILL_VERSIONS, ThreadStateStorage, TABLE_THREAD_STATE, THREAD_STATE_SCHEMA, ToolProviderConnectionsStorage, TOOL_PROVIDER_CONNECTIONS_SCHEMA, TABLE_TOOL_PROVIDER_CONNECTIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, WORKSPACES_SCHEMA, TABLE_WORKSPACES, WORKSPACE_VERSIONS_SCHEMA, TABLE_WORKSPACE_VERSIONS, FactoryStorage, MastraCompositeStore, getSqlType, parseDuration, normalizeScheduleTarget, UniqueViolationError, TraceStatus, mergeWorkflowStepResult } from '@mastra/core/storage';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector, validateTopK, validateUpsertInput } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -1196,26 +1196,28 @@ var LibSQLVector = class extends MastraVector {
     });
   }
 };
+var MAX_DEPTH = 100;
 var safeStringify = (value) => {
   const ancestors = /* @__PURE__ */ new Set();
-  const sanitize = (val) => {
+  const sanitize = (val, depth = 0) => {
     if (val === null || val === void 0) return val;
     if (typeof val === "function") return void 0;
     if (typeof val === "symbol") return void 0;
     if (typeof val === "bigint") return val.toString();
     if (typeof val !== "object") return val;
+    if (depth > MAX_DEPTH) return "[Max depth exceeded]";
     if (ancestors.has(val)) return void 0;
     if (typeof val.toJSON === "function") {
-      return sanitize(val.toJSON());
+      return sanitize(val.toJSON(), depth + 1);
     }
     ancestors.add(val);
     try {
       if (Array.isArray(val)) {
-        return val.map((item) => sanitize(item));
+        return val.map((item) => sanitize(item, depth + 1));
       }
       const result = {};
       for (const key of Object.keys(val)) {
-        const sanitized = sanitize(val[key]);
+        const sanitized = sanitize(val[key], depth + 1);
         if (sanitized !== void 0) {
           result[key] = sanitized;
         }
@@ -13345,6 +13347,388 @@ var WorkspacesLibSQL = class extends WorkspacesStorage {
     };
   }
 };
+var IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var COLUMN_DDL = {
+  text: "TEXT",
+  bigint: "INTEGER",
+  integer: "INTEGER",
+  boolean: "INTEGER",
+  json: "TEXT",
+  timestamp: "TEXT",
+  "uuid-pk": "TEXT"
+};
+function assertIdentifier(kind, name) {
+  if (!IDENTIFIER_RE.test(name)) {
+    throw new Error(`LibSQLFactoryStorage: invalid ${kind} identifier '${name}'`);
+  }
+}
+function isUniqueViolation(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("UNIQUE constraint failed") || message.includes("SQLITE_CONSTRAINT");
+}
+function primaryKeyOf(schema) {
+  const pks = Object.entries(schema.columns).filter(([, spec]) => spec.type === "uuid-pk" || spec.primaryKey);
+  if (pks.length !== 1) {
+    throw new Error(
+      `LibSQLFactoryStorage: collection '${schema.name}' must declare exactly one primary key (found ${pks.length})`
+    );
+  }
+  return pks[0][0];
+}
+function assertUpsertConflict(schema, conflictKeys, row) {
+  const keys = new Set(conflictKeys);
+  if (keys.size !== conflictKeys.length || conflictKeys.some((key) => row[key] === void 0)) {
+    throw new Error(
+      `LibSQLFactoryStorage: upsert conflict keys for '${schema.name}' must be unique and present in the row`
+    );
+  }
+  const primaryKey = primaryKeyOf(schema);
+  const candidates = [{ columns: [primaryKey] }, ...schema.uniqueIndexes ?? []];
+  const matches = candidates.some((candidate) => {
+    if (candidate.columns.length !== keys.size || candidate.columns.some((column) => !keys.has(column))) return false;
+    if ("whereNotNull" in candidate && candidate.whereNotNull && row[candidate.whereNotNull] == null) return false;
+    if ("whereNull" in candidate && candidate.whereNull && row[candidate.whereNull] != null) return false;
+    return true;
+  });
+  if (!matches) {
+    throw new Error(
+      `LibSQLFactoryStorage: upsert conflict keys [${conflictKeys.join(", ")}] do not match an applicable primary key or unique index on '${schema.name}'`
+    );
+  }
+}
+function serializeDefault(value) {
+  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return String(value);
+}
+var Mutex = class {
+  #tail = Promise.resolve();
+  run(fn) {
+    const result = this.#tail.then(fn, fn);
+    this.#tail = result.catch(() => {
+    });
+    return result;
+  }
+};
+var LibSQLFactoryStorageOps = class {
+  #client;
+  #schemas;
+  #writeMutex = new Mutex();
+  constructor(client, schemas) {
+    this.#client = client;
+    this.#schemas = schemas;
+  }
+  #schema(collection) {
+    const schema = this.#schemas.get(collection);
+    if (!schema) {
+      throw new Error(
+        `LibSQLFactoryStorage: unknown collection '${collection}' \u2014 register it via ensureCollections() first`
+      );
+    }
+    return schema;
+  }
+  #column(schema, column) {
+    const spec = schema.columns[column];
+    if (!spec) {
+      throw new Error(`LibSQLFactoryStorage: unknown column '${column}' on collection '${schema.name}'`);
+    }
+    return spec;
+  }
+  #serialize(spec, value) {
+    if (value === null || value === void 0) return null;
+    switch (spec.type) {
+      case "timestamp":
+        return value instanceof Date ? value.toISOString() : String(value);
+      case "boolean":
+        return value ? 1 : 0;
+      case "json":
+        return JSON.stringify(value);
+      case "bigint":
+      case "integer":
+        return Number(value);
+      default:
+        return String(value);
+    }
+  }
+  #deserializeRow(schema, raw) {
+    const row = {};
+    for (const [name, spec] of Object.entries(schema.columns)) {
+      const value = raw[name];
+      if (value === null || value === void 0) {
+        row[name] = null;
+        continue;
+      }
+      switch (spec.type) {
+        case "timestamp":
+          row[name] = new Date(String(value));
+          break;
+        case "boolean":
+          row[name] = Number(value) === 1;
+          break;
+        case "json":
+          row[name] = JSON.parse(String(value));
+          break;
+        case "bigint":
+        case "integer":
+          row[name] = Number(value);
+          break;
+        default:
+          row[name] = String(value);
+      }
+    }
+    return row;
+  }
+  /** Builds `WHERE` SQL (without the keyword). `{}` yields a match-all clause. */
+  #buildWhere(schema, where) {
+    const clauses = [];
+    const args = [];
+    for (const [column, condition] of Object.entries(where)) {
+      const spec = this.#column(schema, column);
+      if (condition !== null && typeof condition === "object" && !(condition instanceof Date) && "in" in condition) {
+        if (condition.in.length === 0) {
+          clauses.push("1 = 0");
+          continue;
+        }
+        const nonNull = condition.in.filter((value) => value !== null);
+        const includesNull = nonNull.length !== condition.in.length;
+        const inClause = nonNull.length > 0 ? `"${column}" IN (${nonNull.map(() => "?").join(", ")})` : void 0;
+        clauses.push(
+          inClause && includesNull ? `(${inClause} OR "${column}" IS NULL)` : inClause ?? `"${column}" IS NULL`
+        );
+        args.push(...nonNull.map((value) => this.#serialize(spec, value)));
+      } else if (condition === null) {
+        clauses.push(`"${column}" IS NULL`);
+      } else {
+        clauses.push(`"${column}" = ?`);
+        args.push(this.#serialize(spec, condition));
+      }
+    }
+    return { sql: clauses.length > 0 ? clauses.join(" AND ") : "1 = 1", args };
+  }
+  /** Keyset condition: rows strictly after `cursor.values` in the `orderBy` order. */
+  #buildCursor(schema, orderBy, values) {
+    if (values.length !== orderBy.length) {
+      throw new Error(
+        `LibSQLFactoryStorage: cursor has ${values.length} values but orderBy has ${orderBy.length} columns`
+      );
+    }
+    const branches = [];
+    const args = [];
+    for (let i = 0; i < orderBy.length; i++) {
+      const parts = [];
+      for (let j = 0; j < i; j++) {
+        const [column2] = orderBy[j];
+        parts.push(`"${column2}" = ?`);
+        args.push(this.#serialize(this.#column(schema, column2), values[j]));
+      }
+      const [column, dir] = orderBy[i];
+      parts.push(`"${column}" ${dir === "desc" ? "<" : ">"} ?`);
+      args.push(this.#serialize(this.#column(schema, column), values[i]));
+      branches.push(`(${parts.join(" AND ")})`);
+    }
+    return { sql: `(${branches.join(" OR ")})`, args };
+  }
+  async #select(collection, where, opts) {
+    const schema = this.#schema(collection);
+    const filter = this.#buildWhere(schema, where);
+    let sql = `SELECT * FROM "${schema.name}" WHERE ${filter.sql}`;
+    const args = [...filter.args];
+    if (opts?.cursor) {
+      if (!opts.orderBy || opts.orderBy.length === 0) {
+        throw new Error("LibSQLFactoryStorage: cursor pagination requires orderBy");
+      }
+      const cursor = this.#buildCursor(schema, opts.orderBy, opts.cursor.values);
+      sql += ` AND ${cursor.sql}`;
+      args.push(...cursor.args);
+    }
+    if (opts?.orderBy && opts.orderBy.length > 0) {
+      const order = opts.orderBy.map(([column, dir]) => {
+        this.#column(schema, column);
+        return `"${column}" ${dir === "desc" ? "DESC" : "ASC"}`;
+      }).join(", ");
+      sql += ` ORDER BY ${order}`;
+    }
+    if (opts?.limit !== void 0) {
+      sql += ` LIMIT ?`;
+      args.push(opts.limit);
+    }
+    const result = await this.#client.execute({ sql, args });
+    return result.rows.map((raw) => this.#deserializeRow(schema, raw));
+  }
+  async findOne(collection, where) {
+    const rows = await this.#select(collection, where, { limit: 1 });
+    return rows[0] ?? null;
+  }
+  async findMany(collection, where, opts) {
+    return this.#select(collection, where, opts);
+  }
+  async insertOne(collection, row) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    const values = { ...row };
+    if (schema.columns[pk].type === "uuid-pk" && values[pk] === void 0) {
+      values[pk] = randomUUID();
+    }
+    const columns = Object.keys(values).filter((column) => values[column] !== void 0);
+    for (const column of columns) this.#column(schema, column);
+    const sql = `INSERT INTO "${schema.name}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+    const args = columns.map((column) => this.#serialize(this.#column(schema, column), values[column]));
+    try {
+      await this.#client.execute({ sql, args });
+    } catch (error) {
+      if (isUniqueViolation(error)) throw new UniqueViolationError(collection, { cause: error });
+      throw error;
+    }
+    const inserted = await this.findOne(collection, { [pk]: values[pk] });
+    if (!inserted) throw new Error(`LibSQLFactoryStorage: failed to read back inserted row from '${collection}'`);
+    return inserted;
+  }
+  async upsertOne(collection, conflictKeys, row) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    assertUpsertConflict(schema, conflictKeys, row);
+    const keyWhere = Object.fromEntries(conflictKeys.map((key) => [key, row[key]]));
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const existing = await this.findOne(collection, keyWhere);
+      if (existing) {
+        const set = Object.fromEntries(
+          Object.entries(row).filter(
+            ([column, value]) => value !== void 0 && column !== pk && !conflictKeys.includes(column)
+          )
+        );
+        if (Object.keys(set).length > 0) {
+          await this.updateMany(collection, { [pk]: existing[pk] }, set);
+        }
+        const updated = await this.findOne(collection, { [pk]: existing[pk] });
+        if (!updated) continue;
+        return updated;
+      }
+      try {
+        return await this.insertOne(collection, row);
+      } catch (error) {
+        if (!(error instanceof UniqueViolationError)) throw error;
+        lastError = error;
+      }
+    }
+    throw lastError ?? new Error(`LibSQLFactoryStorage: upsert into '${collection}' did not converge`);
+  }
+  async updateMany(collection, where, set) {
+    const schema = this.#schema(collection);
+    const columns = Object.keys(set).filter((column) => set[column] !== void 0);
+    if (columns.length === 0) return 0;
+    const filter = this.#buildWhere(schema, where);
+    const sql = `UPDATE "${schema.name}" SET ${columns.map((c) => `"${c}" = ?`).join(", ")} WHERE ${filter.sql}`;
+    const args = [...columns.map((column) => this.#serialize(this.#column(schema, column), set[column])), ...filter.args];
+    const result = await this.#client.execute({ sql, args });
+    return result.rowsAffected;
+  }
+  async deleteMany(collection, where) {
+    const schema = this.#schema(collection);
+    const filter = this.#buildWhere(schema, where);
+    const result = await this.#client.execute({
+      sql: `DELETE FROM "${schema.name}" WHERE ${filter.sql}`,
+      args: filter.args
+    });
+    return result.rowsAffected;
+  }
+  async updateAtomic(collection, where, fn) {
+    const schema = this.#schema(collection);
+    const pk = primaryKeyOf(schema);
+    return this.#writeMutex.run(async () => {
+      const row = await this.findOne(collection, where);
+      if (!row) return null;
+      const patch = await fn(row);
+      if (patch === null) return row;
+      const pkWhere = { [pk]: row[pk] };
+      await this.updateMany(collection, pkWhere, patch);
+      return this.findOne(collection, pkWhere);
+    });
+  }
+};
+var LibSQLFactoryStorage = class extends FactoryStorage {
+  ops;
+  #client;
+  #config;
+  #schemas = /* @__PURE__ */ new Map();
+  #mastraStorage;
+  constructor(config) {
+    super();
+    this.#config = config;
+    const isLocalDb = config.url.startsWith("file:") || config.url.includes(":memory:");
+    this.#client = createClient({
+      url: config.url,
+      ...config.authToken ? { authToken: config.authToken } : {},
+      ...isLocalDb ? { timeout: DEFAULT_CONNECTION_TIMEOUT_MS } : {}
+    });
+    this.ops = new LibSQLFactoryStorageOps(this.#client, this.#schemas);
+  }
+  getMastraStorage() {
+    this.#mastraStorage ??= new LibSQLStore({
+      id: this.#config.id ?? "libsql-factory",
+      client: this.#client,
+      ...this.#config.retention ? { retention: this.#config.retention } : {}
+    });
+    return this.#mastraStorage;
+  }
+  async initStorage() {
+    await this.#client.execute("SELECT 1");
+  }
+  async ensureCollections(schemas) {
+    for (const schema of schemas) {
+      await this.#ensureCollection(schema);
+      this.#schemas.set(schema.name, schema);
+    }
+  }
+  async close() {
+    this.#client.close();
+  }
+  authDatabase() {
+    return { dialect: "libsql", client: this.#client };
+  }
+  #columnDdl(name, spec) {
+    assertIdentifier("column", name);
+    let ddl = `"${name}" ${COLUMN_DDL[spec.type]}`;
+    if (spec.type === "uuid-pk" || spec.primaryKey) ddl += " PRIMARY KEY";
+    if (!spec.nullable && spec.type !== "uuid-pk" && !spec.primaryKey) ddl += " NOT NULL";
+    if (spec.default !== void 0) ddl += ` DEFAULT ${serializeDefault(spec.default)}`;
+    return ddl;
+  }
+  async #ensureCollection(schema) {
+    assertIdentifier("collection", schema.name);
+    primaryKeyOf(schema);
+    const columns = Object.entries(schema.columns).map(([name, spec]) => this.#columnDdl(name, spec));
+    await this.#client.execute(`CREATE TABLE IF NOT EXISTS "${schema.name}" (${columns.join(", ")})`);
+    const info = await this.#client.execute(`PRAGMA table_info("${schema.name}")`);
+    const existing = new Set(info.rows.map((row) => String(row.name)));
+    for (const [name, spec] of Object.entries(schema.columns)) {
+      if (existing.has(name)) continue;
+      await this.#client.execute(`ALTER TABLE "${schema.name}" ADD COLUMN ${this.#columnDdl(name, spec)}`);
+    }
+    for (const index of schema.uniqueIndexes ?? []) {
+      assertIdentifier("index", index.name);
+      index.columns.forEach((column) => assertIdentifier("column", column));
+      let where = "";
+      if (index.whereNotNull) {
+        assertIdentifier("column", index.whereNotNull);
+        where = ` WHERE "${index.whereNotNull}" IS NOT NULL`;
+      } else if (index.whereNull) {
+        assertIdentifier("column", index.whereNull);
+        where = ` WHERE "${index.whereNull}" IS NULL`;
+      }
+      await this.#client.execute(
+        `CREATE UNIQUE INDEX IF NOT EXISTS "${index.name}" ON "${schema.name}" (${index.columns.map((c) => `"${c}"`).join(", ")})${where}`
+      );
+    }
+    for (const index of schema.indexes ?? []) {
+      assertIdentifier("index", index.name);
+      index.columns.forEach((column) => assertIdentifier("column", column));
+      await this.#client.execute(
+        `CREATE INDEX IF NOT EXISTS "${index.name}" ON "${schema.name}" (${index.columns.map((c) => `"${c}"`).join(", ")})`
+      );
+    }
+  }
+};
 
 // src/storage/index.ts
 var DEFAULT_LOCAL_CACHE_SIZE = -16e3;
@@ -13628,6 +14012,6 @@ Example Complex Query:
   ]
 }`;
 
-export { AgentsLibSQL, BackgroundTasksLibSQL, BlobsLibSQL, ChannelsLibSQL, DatasetsLibSQL, LibSQLStore as DefaultStorage, ExperimentsLibSQL, FavoritesLibSQL, HarnessLibSQL, LIBSQL_PROMPT, LibSQLStore, LibSQLVector, MCPClientsLibSQL, MCPServersLibSQL, MemoryLibSQL, NotificationsLibSQL, ObservabilityLibSQL, PromptBlocksLibSQL, SchedulesLibSQL, ScorerDefinitionsLibSQL, ScoresLibSQL, SkillsLibSQL, ThreadStateLibSQL, ToolProviderConnectionsLibSQL, WorkflowsLibSQL, WorkspacesLibSQL };
+export { AgentsLibSQL, BackgroundTasksLibSQL, BlobsLibSQL, ChannelsLibSQL, DatasetsLibSQL, LibSQLStore as DefaultStorage, ExperimentsLibSQL, FavoritesLibSQL, HarnessLibSQL, LIBSQL_PROMPT, LibSQLFactoryStorage, LibSQLStore, LibSQLVector, MCPClientsLibSQL, MCPServersLibSQL, MemoryLibSQL, NotificationsLibSQL, ObservabilityLibSQL, PromptBlocksLibSQL, SchedulesLibSQL, ScorerDefinitionsLibSQL, ScoresLibSQL, SkillsLibSQL, ThreadStateLibSQL, ToolProviderConnectionsLibSQL, WorkflowsLibSQL, WorkspacesLibSQL };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map