@mastra/libsql 0.0.0-studio-deploy-20260404182525 → 0.0.0-studio-cli-20260504022012

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, BlobStore, TABLE_SKILL_BLOBS, SKILL_BLOBS_SCHEMA, DatasetsStorage, DATASETS_SCHEMA, TABLE_DATASETS, DATASET_ITEMS_SCHEMA, TABLE_DATASET_ITEMS, DATASET_VERSIONS_SCHEMA, TABLE_DATASET_VERSIONS, ensureDate, safelyParseJSON, TABLE_EXPERIMENT_RESULTS, TABLE_EXPERIMENTS, ExperimentsStorage, EXPERIMENTS_SCHEMA, EXPERIMENT_RESULTS_SCHEMA, 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_SCHEMAS, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ObservabilityStorage, SPAN_SCHEMA, TABLE_SPANS, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, PROMPT_BLOCKS_SCHEMA, TABLE_PROMPT_BLOCKS, PROMPT_BLOCK_VERSIONS_SCHEMA, TABLE_PROMPT_BLOCK_VERSIONS, ScorerDefinitionsStorage, SCORER_DEFINITIONS_SCHEMA, TABLE_SCORER_DEFINITIONS, SCORER_DEFINITION_VERSIONS_SCHEMA, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, SCORERS_SCHEMA, TABLE_SCORERS, transformScoreRow, SkillsStorage, SKILLS_SCHEMA, TABLE_SKILLS, SKILL_VERSIONS_SCHEMA, TABLE_SKILL_VERSIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, WORKSPACES_SCHEMA, TABLE_WORKSPACES, WORKSPACE_VERSIONS_SCHEMA, TABLE_WORKSPACE_VERSIONS, MastraCompositeStore, getSqlType, TraceStatus } from '@mastra/core/storage';
+import { createVectorErrorId, AgentsStorage, AGENTS_SCHEMA, TABLE_AGENTS, AGENT_VERSIONS_SCHEMA, TABLE_AGENT_VERSIONS, createStorageErrorId, normalizePerPage, calculatePagination, BackgroundTasksStorage, TABLE_SCHEMAS, TABLE_BACKGROUND_TASKS, 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, ensureDate, safelyParseJSON, TABLE_EXPERIMENT_RESULTS, TABLE_EXPERIMENTS, ExperimentsStorage, EXPERIMENTS_SCHEMA, EXPERIMENT_RESULTS_SCHEMA, 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_MESSAGES, TABLE_RESOURCES, ObservabilityStorage, SPAN_SCHEMA, TABLE_SPANS, listTracesArgsSchema, toTraceSpans, PromptBlocksStorage, PROMPT_BLOCKS_SCHEMA, TABLE_PROMPT_BLOCKS, PROMPT_BLOCK_VERSIONS_SCHEMA, TABLE_PROMPT_BLOCK_VERSIONS, SchedulesStorage, TABLE_SCHEDULES, TABLE_SCHEDULE_TRIGGERS, ScorerDefinitionsStorage, SCORER_DEFINITIONS_SCHEMA, TABLE_SCORER_DEFINITIONS, SCORER_DEFINITION_VERSIONS_SCHEMA, TABLE_SCORER_DEFINITION_VERSIONS, ScoresStorage, SCORERS_SCHEMA, TABLE_SCORERS, transformScoreRow, SkillsStorage, SKILLS_SCHEMA, TABLE_SKILLS, SKILL_VERSIONS_SCHEMA, TABLE_SKILL_VERSIONS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, WorkspacesStorage, WORKSPACES_SCHEMA, TABLE_WORKSPACES, WORKSPACE_VERSIONS_SCHEMA, TABLE_WORKSPACE_VERSIONS, MastraCompositeStore, getSqlType, TraceStatus } 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';
@@ -509,6 +509,9 @@ var LibSQLVector = class extends MastraVector {
   turso;
   maxRetries;
   initialBackoffMs;
+  overFetchMultiplier;
+  isMemoryDb;
+  vectorIndexes;
   constructor({
     url,
     authToken,
@@ -516,6 +519,7 @@ var LibSQLVector = class extends MastraVector {
     syncInterval,
     maxRetries = 5,
     initialBackoffMs = 100,
+    vectorTopKOverFetchMultiplier = 10,
     id
   }) {
     super({ id });
@@ -527,10 +531,27 @@ var LibSQLVector = class extends MastraVector {
     });
     this.maxRetries = maxRetries;
     this.initialBackoffMs = initialBackoffMs;
-    if (url.includes(`file:`) || url.includes(`:memory:`)) {
+    if (!Number.isInteger(vectorTopKOverFetchMultiplier) || vectorTopKOverFetchMultiplier < 1) {
+      throw new Error("vectorTopKOverFetchMultiplier must be a positive integer");
+    }
+    this.overFetchMultiplier = vectorTopKOverFetchMultiplier;
+    this.isMemoryDb = url.includes(":memory:");
+    if (url.includes(`file:`) || this.isMemoryDb) {
       this.turso.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
       this.turso.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout=5000.", err));
     }
+    this.vectorIndexes = this.isMemoryDb ? Promise.resolve(/* @__PURE__ */ new Set()) : this.discoverVectorIndexes();
+  }
+  async discoverVectorIndexes() {
+    try {
+      const result = await this.turso.execute({
+        sql: `SELECT name FROM sqlite_master WHERE type='index' AND name LIKE '%_vector_idx'`,
+        args: []
+      });
+      return new Set(result.rows.map((row) => row.name));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
   }
   async executeWriteOperationWithRetry(operation, isTransaction = false) {
     let attempts = 0;
@@ -564,6 +585,40 @@ var LibSQLVector = class extends MastraVector {
     const translator = new LibSQLFilterTranslator();
     return translator.translate(filter);
   }
+  async hasVectorIndex(parsedIndexName) {
+    const indexes = await this.vectorIndexes;
+    return indexes.has(`${parsedIndexName}_vector_idx`);
+  }
+  async queryWithIndex(parsedIndexName, vectorStr, topK, filter, includeVector, minScore) {
+    const translatedFilter = this.transformFilter(filter);
+    const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
+    const hasFilter = filterQuery.length > 0;
+    const fetchCount = hasFilter ? topK * this.overFetchMultiplier : topK * 2;
+    const embeddingSelect = includeVector ? ", vector_extract(t.embedding) as embedding" : "";
+    const filterCondition = hasFilter ? filterQuery.replace(/^\s*WHERE\s+/i, "") : "";
+    const whereClause = hasFilter ? `WHERE ${filterCondition} AND score > ?` : "WHERE score > ?";
+    const query = `
+      WITH candidates AS (
+        SELECT t.vector_id AS id,
+               (1 - vector_distance_cos(t.embedding, vector32(?))) AS score,
+               t.metadata
+               ${embeddingSelect}
+        FROM vector_top_k('${parsedIndexName}_vector_idx', vector32(?), ?) AS v
+        JOIN "${parsedIndexName}" AS t ON t.rowid = v.id
+      )
+      SELECT * FROM candidates
+      ${whereClause}
+      ORDER BY score DESC
+      LIMIT ?`;
+    const args = [vectorStr, vectorStr, fetchCount, ...filterValues, minScore, topK];
+    const result = await this.turso.execute({ sql: query, args });
+    return result.rows.map(({ id, score, metadata, embedding }) => ({
+      id,
+      score,
+      metadata: JSON.parse(metadata ?? "{}"),
+      ...includeVector && embedding && { vector: JSON.parse(embedding) }
+    }));
+  }
   async query({
     indexName,
     queryVector,
@@ -594,6 +649,23 @@ var LibSQLVector = class extends MastraVector {
     try {
       const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const vectorStr = `[${queryVector.join(",")}]`;
+      if (!this.isMemoryDb && await this.hasVectorIndex(parsedIndexName)) {
+        try {
+          const indexedResults = await this.queryWithIndex(
+            parsedIndexName,
+            vectorStr,
+            topK,
+            filter,
+            includeVector,
+            minScore
+          );
+          if (!filter || indexedResults.length >= topK) {
+            return indexedResults;
+          }
+        } catch (err) {
+          this.logger.warn("LibSQLVector: indexed query failed, falling back to brute-force", err);
+        }
+      }
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
       filterValues.push(minScore);
@@ -727,6 +799,7 @@ var LibSQLVector = class extends MastraVector {
         `,
       args: []
     });
+    void this.vectorIndexes.then((indexes) => indexes.add(`${parsedIndexName}_vector_idx`));
   }
   deleteIndex(args) {
     try {
@@ -749,6 +822,7 @@ var LibSQLVector = class extends MastraVector {
       sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
       args: []
     });
+    void this.vectorIndexes.then((indexes) => indexes.delete(`${parsedIndexName}_vector_idx`));
   }
   async listIndexes() {
     try {
@@ -1285,6 +1359,9 @@ function transformFromSqlRow({
   const dateColumns = new Set(
     Object.keys(TABLE_SCHEMAS[tableName]).filter((key) => TABLE_SCHEMAS[tableName][key].type === "timestamp").map((key) => key)
   );
+  const booleanColumns = new Set(
+    Object.keys(TABLE_SCHEMAS[tableName]).filter((key) => TABLE_SCHEMAS[tableName][key].type === "boolean").map((key) => key)
+  );
   for (const [key, value] of Object.entries(sqlRow)) {
     if (value === null || value === void 0) {
       result[key] = value;
@@ -1298,6 +1375,10 @@ function transformFromSqlRow({
       result[key] = safelyParseJSON(value);
       continue;
     }
+    if (booleanColumns.has(key)) {
+      result[key] = Boolean(value);
+      continue;
+    }
     result[key] = value;
   }
   return result;
@@ -2882,6 +2963,235 @@ var AgentsLibSQL = class extends AgentsStorage {
     };
   }
 };
+function serializeJson(v) {
+  if (typeof v === "object" && v != null) return JSON.stringify(v);
+  return v ?? null;
+}
+function parseJson(val) {
+  if (val == null) return void 0;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+}
+function rowToTask(row) {
+  return {
+    id: String(row.id),
+    status: String(row.status),
+    toolName: String(row.tool_name),
+    toolCallId: String(row.tool_call_id),
+    args: parseJson(row.args) ?? {},
+    agentId: String(row.agent_id),
+    threadId: row.thread_id != null ? String(row.thread_id) : void 0,
+    resourceId: row.resource_id != null ? String(row.resource_id) : void 0,
+    runId: String(row.run_id),
+    result: parseJson(row.result),
+    error: parseJson(row.error),
+    retryCount: Number(row.retry_count),
+    maxRetries: Number(row.max_retries),
+    timeoutMs: Number(row.timeout_ms),
+    createdAt: new Date(String(row.createdAt)),
+    startedAt: row.startedAt ? new Date(String(row.startedAt)) : void 0,
+    completedAt: row.completedAt ? new Date(String(row.completedAt)) : void 0
+  };
+}
+var BackgroundTasksLibSQL = class extends BackgroundTasksStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: TABLE_BACKGROUND_TASKS,
+      schema: TABLE_SCHEMAS[TABLE_BACKGROUND_TASKS]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_BACKGROUND_TASKS });
+  }
+  async createTask(task) {
+    await this.#db.insert({
+      tableName: TABLE_BACKGROUND_TASKS,
+      record: {
+        id: task.id,
+        tool_call_id: task.toolCallId,
+        tool_name: task.toolName,
+        agent_id: task.agentId,
+        thread_id: task.threadId ?? null,
+        resource_id: task.resourceId ?? null,
+        run_id: task.runId,
+        status: task.status,
+        args: task.args,
+        result: task.result ?? null,
+        error: task.error ?? null,
+        retry_count: task.retryCount,
+        max_retries: task.maxRetries,
+        timeout_ms: task.timeoutMs,
+        createdAt: task.createdAt.toISOString(),
+        startedAt: task.startedAt?.toISOString() ?? null,
+        completedAt: task.completedAt?.toISOString() ?? null
+      }
+    });
+  }
+  async updateTask(taskId, update) {
+    const setClauses = [];
+    const params = [];
+    if ("status" in update) {
+      setClauses.push("status = ?");
+      params.push(update.status);
+    }
+    if ("result" in update) {
+      setClauses.push("result = jsonb(?)");
+      params.push(serializeJson(update.result));
+    }
+    if ("error" in update) {
+      setClauses.push("error = jsonb(?)");
+      params.push(serializeJson(update.error));
+    }
+    if ("retryCount" in update) {
+      setClauses.push("retry_count = ?");
+      params.push(update.retryCount);
+    }
+    if ("startedAt" in update) {
+      setClauses.push("startedAt = ?");
+      params.push(update.startedAt?.toISOString() ?? null);
+    }
+    if ("completedAt" in update) {
+      setClauses.push("completedAt = ?");
+      params.push(update.completedAt?.toISOString() ?? null);
+    }
+    if (setClauses.length === 0) return;
+    params.push(taskId);
+    await this.#client.execute({
+      sql: `UPDATE ${TABLE_BACKGROUND_TASKS} SET ${setClauses.join(", ")} WHERE id = ?`,
+      args: params
+    });
+  }
+  async getTask(taskId) {
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(TABLE_BACKGROUND_TASKS)} FROM ${TABLE_BACKGROUND_TASKS} WHERE id = ?`,
+      args: [taskId]
+    });
+    const row = result.rows[0];
+    return row ? rowToTask(row) : null;
+  }
+  async listTasks(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      conditions.push(`status IN (${statuses.map(() => "?").join(", ")})`);
+      params.push(...statuses);
+    }
+    if (filter.agentId) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agentId);
+    }
+    if (filter.threadId) {
+      conditions.push("thread_id = ?");
+      params.push(filter.threadId);
+    }
+    if (filter.runId) {
+      conditions.push("run_id = ?");
+      params.push(filter.runId);
+    }
+    if (filter.resourceId) {
+      conditions.push("resource_id = ?");
+      params.push(filter.resourceId);
+    }
+    if (filter.toolName) {
+      conditions.push("tool_name = ?");
+      params.push(filter.toolName);
+    }
+    const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+    if (filter.fromDate) {
+      conditions.push(`${dateCol} >= ?`);
+      params.push(filter.fromDate.toISOString());
+    }
+    if (filter.toDate) {
+      conditions.push(`${dateCol} < ?`);
+      params.push(filter.toDate.toISOString());
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await this.#client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${TABLE_BACKGROUND_TASKS} ${where}`,
+      args: [...params]
+    });
+    const total = Number(countResult.rows[0]?.count ?? 0);
+    const orderCol = filter.orderBy === "startedAt" ? "startedAt" : filter.orderBy === "completedAt" ? "completedAt" : "createdAt";
+    const direction = filter.orderDirection === "desc" ? "DESC" : "ASC";
+    let sql = `SELECT ${buildSelectColumns(TABLE_BACKGROUND_TASKS)} FROM ${TABLE_BACKGROUND_TASKS} ${where} ORDER BY ${orderCol} ${direction}`;
+    if (filter.perPage != null) {
+      sql += " LIMIT ?";
+      params.push(filter.perPage);
+      if (filter.page != null) {
+        sql += " OFFSET ?";
+        params.push(filter.page * filter.perPage);
+      }
+    }
+    const result = await this.#client.execute({ sql, args: params });
+    return { tasks: result.rows.map((row) => rowToTask(row)), total };
+  }
+  async deleteTask(taskId) {
+    await this.#client.execute({
+      sql: `DELETE FROM ${TABLE_BACKGROUND_TASKS} WHERE id = ?`,
+      args: [taskId]
+    });
+  }
+  async deleteTasks(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      conditions.push(`status IN (${statuses.map(() => "?").join(", ")})`);
+      params.push(...statuses);
+    }
+    const dateCol = filter.dateFilterBy === "startedAt" ? "startedAt" : filter.dateFilterBy === "completedAt" ? "completedAt" : "createdAt";
+    if (filter.fromDate) {
+      conditions.push(`${dateCol} >= ?`);
+      params.push(filter.fromDate.toISOString());
+    }
+    if (filter.toDate) {
+      conditions.push(`${dateCol} < ?`);
+      params.push(filter.toDate.toISOString());
+    }
+    if (filter.agentId) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agentId);
+    }
+    if (filter.runId) {
+      conditions.push("run_id = ?");
+      params.push(filter.runId);
+    }
+    if (conditions.length === 0) return;
+    await this.#client.execute({
+      sql: `DELETE FROM ${TABLE_BACKGROUND_TASKS} WHERE ${conditions.join(" AND ")}`,
+      args: params
+    });
+  }
+  async getRunningCount() {
+    const result = await this.#client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${TABLE_BACKGROUND_TASKS} WHERE status = 'running'`,
+      args: []
+    });
+    return Number(result.rows[0]?.count ?? 0);
+  }
+  async getRunningCountByAgent(agentId) {
+    const result = await this.#client.execute({
+      sql: `SELECT COUNT(*) as count FROM ${TABLE_BACKGROUND_TASKS} WHERE status = 'running' AND agent_id = ?`,
+      args: [agentId]
+    });
+    return Number(result.rows[0]?.count ?? 0);
+  }
+};
 var BlobsLibSQL = class extends BlobStore {
   #db;
   #client;
@@ -2968,6 +3278,149 @@ var BlobsLibSQL = class extends BlobStore {
     };
   }
 };
+var ChannelsLibSQL = class extends ChannelsStorage {
+  #db;
+  #client;
+  static MANAGED_TABLES = [TABLE_CHANNEL_INSTALLATIONS, TABLE_CHANNEL_CONFIG];
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: TABLE_CHANNEL_INSTALLATIONS,
+      schema: TABLE_SCHEMAS[TABLE_CHANNEL_INSTALLATIONS]
+    });
+    await this.#db.createTable({
+      tableName: TABLE_CHANNEL_CONFIG,
+      schema: TABLE_SCHEMAS[TABLE_CHANNEL_CONFIG]
+    });
+    await this.#client.execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_installations_webhook ON "${TABLE_CHANNEL_INSTALLATIONS}" ("webhookId")`
+    );
+    await this.#client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_channel_installations_platform_agent ON "${TABLE_CHANNEL_INSTALLATIONS}" ("platform", "agentId")`
+    );
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_CHANNEL_INSTALLATIONS });
+    await this.#db.deleteData({ tableName: TABLE_CHANNEL_CONFIG });
+  }
+  async saveInstallation(installation) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.#client.execute({
+      sql: `
+        INSERT INTO "${TABLE_CHANNEL_INSTALLATIONS}" (id, platform, agentId, status, webhookId, data, configHash, error, createdAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          platform = excluded.platform,
+          agentId = excluded.agentId,
+          status = excluded.status,
+          webhookId = excluded.webhookId,
+          data = excluded.data,
+          configHash = excluded.configHash,
+          error = excluded.error,
+          updatedAt = excluded.updatedAt
+      `,
+      args: [
+        installation.id,
+        installation.platform,
+        installation.agentId,
+        installation.status,
+        installation.webhookId ?? null,
+        JSON.stringify(installation.data),
+        installation.configHash ?? null,
+        installation.error ?? null,
+        installation.createdAt?.toISOString() ?? now,
+        now
+      ]
+    });
+  }
+  async getInstallation(id) {
+    const result = await this.#client.execute({
+      sql: `SELECT * FROM "${TABLE_CHANNEL_INSTALLATIONS}" WHERE id = ?`,
+      args: [id]
+    });
+    const row = result.rows?.[0];
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async getInstallationByAgent(platform, agentId) {
+    const result = await this.#client.execute({
+      sql: `SELECT * FROM "${TABLE_CHANNEL_INSTALLATIONS}" WHERE platform = ? AND agentId = ? ORDER BY CASE status WHEN 'active' THEN 0 WHEN 'pending' THEN 1 ELSE 2 END, updatedAt DESC LIMIT 1`,
+      args: [platform, agentId]
+    });
+    const row = result.rows?.[0];
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async getInstallationByWebhookId(webhookId) {
+    const result = await this.#client.execute({
+      sql: `SELECT * FROM "${TABLE_CHANNEL_INSTALLATIONS}" WHERE webhookId = ?`,
+      args: [webhookId]
+    });
+    const row = result.rows?.[0];
+    return row ? this.#parseInstallationRow(row) : null;
+  }
+  async listInstallations(platform) {
+    const result = await this.#client.execute({
+      sql: `SELECT * FROM "${TABLE_CHANNEL_INSTALLATIONS}" WHERE platform = ? ORDER BY createdAt DESC`,
+      args: [platform]
+    });
+    return result.rows.map((row) => this.#parseInstallationRow(row));
+  }
+  async deleteInstallation(id) {
+    await this.#client.execute({
+      sql: `DELETE FROM "${TABLE_CHANNEL_INSTALLATIONS}" WHERE id = ?`,
+      args: [id]
+    });
+  }
+  async saveConfig(config) {
+    await this.#client.execute({
+      sql: `
+        INSERT INTO "${TABLE_CHANNEL_CONFIG}" (platform, data, updatedAt)
+        VALUES (?, ?, ?)
+        ON CONFLICT(platform) DO UPDATE SET
+          data = excluded.data,
+          updatedAt = excluded.updatedAt
+      `,
+      args: [config.platform, JSON.stringify(config.data), config.updatedAt.toISOString()]
+    });
+  }
+  async getConfig(platform) {
+    const result = await this.#client.execute({
+      sql: `SELECT * FROM "${TABLE_CHANNEL_CONFIG}" WHERE platform = ?`,
+      args: [platform]
+    });
+    const row = result.rows?.[0];
+    if (!row) return null;
+    return {
+      platform: row.platform,
+      data: JSON.parse(row.data || "{}"),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async deleteConfig(platform) {
+    await this.#client.execute({
+      sql: `DELETE FROM "${TABLE_CHANNEL_CONFIG}" WHERE platform = ?`,
+      args: [platform]
+    });
+  }
+  #parseInstallationRow(row) {
+    return {
+      id: row.id,
+      platform: row.platform,
+      agentId: row.agentId,
+      status: row.status,
+      webhookId: row.webhookId || void 0,
+      data: JSON.parse(row.data || "{}"),
+      configHash: row.configHash || void 0,
+      error: row.error || void 0,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+};
 function jsonbArg(value) {
   return value === void 0 || value === null ? null : JSON.stringify(value);
 }
@@ -3902,6 +4355,16 @@ var ExperimentsLibSQL = class extends ExperimentsStorage {
       tableName: TABLE_EXPERIMENT_RESULTS,
       schema: EXPERIMENT_RESULTS_SCHEMA
     });
+    await this.#db.alterTable({
+      tableName: TABLE_EXPERIMENTS,
+      schema: EXPERIMENTS_SCHEMA,
+      ifNotExists: ["agentVersion"]
+    });
+    await this.#db.alterTable({
+      tableName: TABLE_EXPERIMENT_RESULTS,
+      schema: EXPERIMENT_RESULTS_SCHEMA,
+      ifNotExists: ["status", "tags"]
+    });
     await this.#client.execute({
       sql: `CREATE INDEX IF NOT EXISTS idx_experiments_datasetid ON "${TABLE_EXPERIMENTS}" ("datasetId")`,
       args: []
@@ -4122,6 +4585,22 @@ var ExperimentsLibSQL = class extends ExperimentsStorage {
         conditions.push("datasetId = ?");
         queryParams.push(args.datasetId);
       }
+      if (args.targetType) {
+        conditions.push("targetType = ?");
+        queryParams.push(args.targetType);
+      }
+      if (args.targetId) {
+        conditions.push("targetId = ?");
+        queryParams.push(args.targetId);
+      }
+      if (args.agentVersion) {
+        conditions.push("agentVersion = ?");
+        queryParams.push(args.agentVersion);
+      }
+      if (args.status) {
+        conditions.push("status = ?");
+        queryParams.push(args.status);
+      }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${TABLE_EXPERIMENTS} ${whereClause}`,
@@ -4324,6 +4803,14 @@ var ExperimentsLibSQL = class extends ExperimentsStorage {
       const { page, perPage: perPageInput } = args.pagination;
       const conditions = ["experimentId = ?"];
       const queryParams = [args.experimentId];
+      if (args.traceId) {
+        conditions.push("traceId = ?");
+        queryParams.push(args.traceId);
+      }
+      if (args.status) {
+        conditions.push("status = ?");
+        queryParams.push(args.status);
+      }
       const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${TABLE_EXPERIMENT_RESULTS} ${whereClause}`,
@@ -6555,14 +7042,26 @@ var MemoryLibSQL = class extends MemoryStorage {
       );
     }
   }
-  async getObservationalMemoryHistory(threadId, resourceId, limit = 10) {
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10, options) {
     try {
       const lookupKey = this.getOMKey(threadId, resourceId);
-      const result = await this.#client.execute({
-        // Use generationCount DESC for reliable ordering (incremented for each new record)
-        sql: `SELECT * FROM "${OM_TABLE}" WHERE "lookupKey" = ? ORDER BY "generationCount" DESC LIMIT ?`,
-        args: [lookupKey, limit]
-      });
+      const conditions = [`"lookupKey" = ?`];
+      const args = [lookupKey];
+      if (options?.from) {
+        conditions.push(`"createdAt" >= ?`);
+        args.push(options.from.toISOString());
+      }
+      if (options?.to) {
+        conditions.push(`"createdAt" <= ?`);
+        args.push(options.to.toISOString());
+      }
+      args.push(limit);
+      let sql = `SELECT * FROM "${OM_TABLE}" WHERE ${conditions.join(" AND ")} ORDER BY "generationCount" DESC LIMIT ?`;
+      if (options?.offset != null) {
+        args.push(options.offset);
+        sql += ` OFFSET ?`;
+      }
+      const result = await this.#client.execute({ sql, args });
       if (!result.rows) return [];
       return result.rows.map((row) => this.parseOMRow(row));
     } catch (error) {
@@ -7032,6 +7531,43 @@ var MemoryLibSQL = class extends MemoryStorage {
       );
     }
   }
+  async updateObservationalMemoryConfig(input) {
+    try {
+      const selectResult = await this.#client.execute({
+        sql: `SELECT config FROM "${OM_TABLE}" WHERE id = ?`,
+        args: [input.id]
+      });
+      if (selectResult.rows.length === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "UPDATE_OM_CONFIG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+      const row = selectResult.rows[0];
+      const existing = row.config ? JSON.parse(row.config) : {};
+      const merged = this.deepMergeConfig(existing, input.config);
+      await this.#client.execute({
+        sql: `UPDATE "${OM_TABLE}" SET config = ?, "updatedAt" = ? WHERE id = ?`,
+        args: [JSON.stringify(merged), (/* @__PURE__ */ new Date()).toISOString(), input.id]
+      });
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "UPDATE_OM_CONFIG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error
+      );
+    }
+  }
   // ============================================
   // Async Buffering Methods
   // ============================================
@@ -7538,6 +8074,39 @@ var ObservabilityLibSQL = class extends ObservabilityStorage {
       );
     }
   }
+  async getTraceLight(args) {
+    const { traceId } = args;
+    try {
+      const spans = await this.#db.selectMany({
+        tableName: TABLE_SPANS,
+        whereClause: { sql: " WHERE traceId = ?", args: [traceId] },
+        orderBy: "startedAt ASC"
+      });
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map((span) => {
+          const transformed = transformFromSqlRow({ tableName: TABLE_SPANS, sqlRow: span });
+          const { input, output, attributes, metadata, tags, links, ...light } = transformed;
+          return light;
+        })
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "GET_TRACE_LIGHT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error
+      );
+    }
+  }
   async updateSpan(args) {
     const { traceId, spanId, updates } = args;
     try {
@@ -8325,6 +8894,233 @@ var PromptBlocksLibSQL = class extends PromptBlocksStorage {
     };
   }
 };
+function parseJson2(val) {
+  if (val == null) return void 0;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+}
+function toNumber(val) {
+  if (typeof val === "bigint") return Number(val);
+  return Number(val);
+}
+function rowToSchedule(row) {
+  const target = parseJson2(row.target);
+  if (!target) {
+    throw new Error(`Schedule row ${row.id} has invalid target`);
+  }
+  const schedule = {
+    id: String(row.id),
+    target,
+    cron: String(row.cron),
+    status: String(row.status),
+    nextFireAt: toNumber(row.next_fire_at),
+    createdAt: toNumber(row.created_at),
+    updatedAt: toNumber(row.updated_at)
+  };
+  if (row.timezone != null) schedule.timezone = String(row.timezone);
+  if (row.last_fire_at != null) schedule.lastFireAt = toNumber(row.last_fire_at);
+  if (row.last_run_id != null) schedule.lastRunId = String(row.last_run_id);
+  const metadata = parseJson2(row.metadata);
+  if (metadata !== void 0) schedule.metadata = metadata;
+  return schedule;
+}
+function rowToTrigger(row) {
+  const trigger = {
+    scheduleId: String(row.schedule_id),
+    runId: String(row.run_id),
+    scheduledFireAt: toNumber(row.scheduled_fire_at),
+    actualFireAt: toNumber(row.actual_fire_at),
+    status: String(row.status)
+  };
+  if (row.error != null) trigger.error = String(row.error);
+  return trigger;
+}
+var SchedulesLibSQL = class extends SchedulesStorage {
+  #db;
+  #client;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: TABLE_SCHEDULES,
+      schema: TABLE_SCHEMAS[TABLE_SCHEDULES]
+    });
+    await this.#db.createTable({
+      tableName: TABLE_SCHEDULE_TRIGGERS,
+      schema: TABLE_SCHEMAS[TABLE_SCHEDULE_TRIGGERS]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: TABLE_SCHEDULE_TRIGGERS });
+    await this.#db.deleteData({ tableName: TABLE_SCHEDULES });
+  }
+  async createSchedule(schedule) {
+    const existing = await this.getSchedule(schedule.id);
+    if (existing) {
+      throw new Error(`Schedule with id "${schedule.id}" already exists`);
+    }
+    await this.#db.insert({
+      tableName: TABLE_SCHEDULES,
+      record: {
+        id: schedule.id,
+        target: schedule.target,
+        cron: schedule.cron,
+        timezone: schedule.timezone ?? null,
+        status: schedule.status,
+        next_fire_at: schedule.nextFireAt,
+        last_fire_at: schedule.lastFireAt ?? null,
+        last_run_id: schedule.lastRunId ?? null,
+        created_at: schedule.createdAt,
+        updated_at: schedule.updatedAt,
+        metadata: schedule.metadata ?? null
+      }
+    });
+    return schedule;
+  }
+  async getSchedule(id) {
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(TABLE_SCHEDULES)} FROM ${TABLE_SCHEDULES} WHERE id = ?`,
+      args: [id]
+    });
+    const row = result.rows[0];
+    return row ? rowToSchedule(row) : null;
+  }
+  async listSchedules(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter?.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter?.workflowId) {
+      conditions.push("json_extract(target, '$.workflowId') = ?");
+      params.push(filter.workflowId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(TABLE_SCHEDULES)} FROM ${TABLE_SCHEDULES} ${where} ORDER BY created_at ASC`,
+      args: params
+    });
+    return result.rows.map((r) => rowToSchedule(r));
+  }
+  async listDueSchedules(now, limit) {
+    const cap = limit ?? 100;
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(TABLE_SCHEDULES)} FROM ${TABLE_SCHEDULES}
+            WHERE status = ? AND next_fire_at <= ?
+            ORDER BY next_fire_at ASC
+            LIMIT ?`,
+      args: ["active", now, cap]
+    });
+    return result.rows.map((r) => rowToSchedule(r));
+  }
+  async updateSchedule(id, patch) {
+    const setClauses = [];
+    const params = [];
+    if ("cron" in patch && patch.cron !== void 0) {
+      setClauses.push("cron = ?");
+      params.push(patch.cron);
+    }
+    if ("timezone" in patch) {
+      setClauses.push("timezone = ?");
+      params.push(patch.timezone ?? null);
+    }
+    if ("status" in patch && patch.status !== void 0) {
+      setClauses.push("status = ?");
+      params.push(patch.status);
+    }
+    if ("nextFireAt" in patch && patch.nextFireAt !== void 0) {
+      setClauses.push("next_fire_at = ?");
+      params.push(patch.nextFireAt);
+    }
+    if ("target" in patch && patch.target !== void 0) {
+      setClauses.push("target = jsonb(?)");
+      params.push(JSON.stringify(patch.target));
+    }
+    if ("metadata" in patch) {
+      setClauses.push("metadata = jsonb(?)");
+      params.push(patch.metadata != null ? JSON.stringify(patch.metadata) : null);
+    }
+    setClauses.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    if (setClauses.length === 1) {
+      const existing = await this.getSchedule(id);
+      if (!existing) throw new Error(`Schedule ${id} not found`);
+      return existing;
+    }
+    await this.#client.execute({
+      sql: `UPDATE ${TABLE_SCHEDULES} SET ${setClauses.join(", ")} WHERE id = ?`,
+      args: params
+    });
+    const updated = await this.getSchedule(id);
+    if (!updated) throw new Error(`Schedule ${id} not found`);
+    return updated;
+  }
+  async updateScheduleNextFire(id, expectedNextFireAt, newNextFireAt, lastFireAt, lastRunId) {
+    const result = await this.#client.execute({
+      sql: `UPDATE ${TABLE_SCHEDULES}
+            SET next_fire_at = ?, last_fire_at = ?, last_run_id = ?, updated_at = ?
+            WHERE id = ? AND next_fire_at = ? AND status = ?`,
+      args: [newNextFireAt, lastFireAt, lastRunId, Date.now(), id, expectedNextFireAt, "active"]
+    });
+    return (result.rowsAffected ?? 0) > 0;
+  }
+  async deleteSchedule(id) {
+    await this.#client.execute({
+      sql: `DELETE FROM ${TABLE_SCHEDULE_TRIGGERS} WHERE schedule_id = ?`,
+      args: [id]
+    });
+    await this.#client.execute({
+      sql: `DELETE FROM ${TABLE_SCHEDULES} WHERE id = ?`,
+      args: [id]
+    });
+  }
+  async recordTrigger(trigger) {
+    await this.#db.insert({
+      tableName: TABLE_SCHEDULE_TRIGGERS,
+      record: {
+        schedule_id: trigger.scheduleId,
+        run_id: trigger.runId,
+        scheduled_fire_at: trigger.scheduledFireAt,
+        actual_fire_at: trigger.actualFireAt,
+        status: trigger.status,
+        error: trigger.error ?? null
+      }
+    });
+  }
+  async listTriggers(scheduleId, opts) {
+    const conditions = ["schedule_id = ?"];
+    const params = [scheduleId];
+    if (opts?.fromActualFireAt != null) {
+      conditions.push("actual_fire_at >= ?");
+      params.push(opts.fromActualFireAt);
+    }
+    if (opts?.toActualFireAt != null) {
+      conditions.push("actual_fire_at < ?");
+      params.push(opts.toActualFireAt);
+    }
+    const limitClause = opts?.limit != null ? `LIMIT ${Math.floor(opts.limit)}` : "";
+    const result = await this.#client.execute({
+      sql: `SELECT ${buildSelectColumns(TABLE_SCHEDULE_TRIGGERS)} FROM ${TABLE_SCHEDULE_TRIGGERS}
+            WHERE ${conditions.join(" AND ")}
+            ORDER BY actual_fire_at DESC
+            ${limitClause}`,
+      args: params
+    });
+    return result.rows.map((r) => rowToTrigger(r));
+  }
+};
 var ScorerDefinitionsLibSQL = class extends ScorerDefinitionsStorage {
   #db;
   #client;
@@ -10545,6 +11341,7 @@ var LibSQLStore = class extends MastraCompositeStore {
     const memory = new MemoryLibSQL(domainConfig);
     const observability = new ObservabilityLibSQL(domainConfig);
     const agents = new AgentsLibSQL(domainConfig);
+    const channels = new ChannelsLibSQL(domainConfig);
     const datasets = new DatasetsLibSQL(domainConfig);
     const experiments = new ExperimentsLibSQL(domainConfig);
     const promptBlocks = new PromptBlocksLibSQL(domainConfig);
@@ -10554,12 +11351,15 @@ var LibSQLStore = class extends MastraCompositeStore {
     const workspaces = new WorkspacesLibSQL(domainConfig);
     const skills = new SkillsLibSQL(domainConfig);
     const blobs = new BlobsLibSQL(domainConfig);
+    const backgroundTasks = new BackgroundTasksLibSQL(domainConfig);
+    const schedules = new SchedulesLibSQL(domainConfig);
     this.stores = {
       scores,
       workflows,
       memory,
       observability,
       agents,
+      channels,
       datasets,
       experiments,
       promptBlocks,
@@ -10568,7 +11368,9 @@ var LibSQLStore = class extends MastraCompositeStore {
       mcpServers,
       workspaces,
       skills,
-      blobs
+      blobs,
+      backgroundTasks,
+      schedules
     };
   }
 };
@@ -10672,6 +11474,6 @@ Example Complex Query:
   ]
 }`;
 
-export { AgentsLibSQL, BlobsLibSQL, DatasetsLibSQL, LibSQLStore as DefaultStorage, ExperimentsLibSQL, LIBSQL_PROMPT, LibSQLStore, LibSQLVector, MCPClientsLibSQL, MCPServersLibSQL, MemoryLibSQL, ObservabilityLibSQL, PromptBlocksLibSQL, ScorerDefinitionsLibSQL, ScoresLibSQL, SkillsLibSQL, WorkflowsLibSQL, WorkspacesLibSQL };
+export { AgentsLibSQL, BackgroundTasksLibSQL, BlobsLibSQL, ChannelsLibSQL, DatasetsLibSQL, LibSQLStore as DefaultStorage, ExperimentsLibSQL, LIBSQL_PROMPT, LibSQLStore, LibSQLVector, MCPClientsLibSQL, MCPServersLibSQL, MemoryLibSQL, ObservabilityLibSQL, PromptBlocksLibSQL, SchedulesLibSQL, ScorerDefinitionsLibSQL, ScoresLibSQL, SkillsLibSQL, WorkflowsLibSQL, WorkspacesLibSQL };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map