@mastra/core 0.2.0-alpha.99 → 0.2.0

package/dist/chunk-VOUPGVRD.js

@@ -1,27 +0,0 @@
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-
-// src/tools/tool.ts
-var _Tool = class _Tool {
-  constructor(opts) {
-    __publicField(this, "id");
-    __publicField(this, "description");
-    __publicField(this, "inputSchema");
-    __publicField(this, "outputSchema");
-    __publicField(this, "execute");
-    __publicField(this, "mastra");
-    this.id = opts.id;
-    this.description = opts.description;
-    this.inputSchema = opts.inputSchema;
-    this.outputSchema = opts.outputSchema;
-    this.execute = opts.execute;
-    this.mastra = opts.mastra;
-  }
-};
-__name(_Tool, "Tool");
-var Tool = _Tool;
-function createTool(opts) {
-  return new Tool(opts);
-}
-__name(createTool, "createTool");
-
-export { Tool, createTool };

package/dist/chunk-Z7JFMQZZ.js

@@ -1,551 +0,0 @@
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-import { createClient } from '@libsql/client';
-import { join } from 'path';
-
-// src/storage/base.ts
-var _MastraStorage = class _MastraStorage extends MastraBase {
-  constructor({ name }) {
-    super({
-      component: "STORAGE",
-      name
-    });
-    __publicField(this, "hasInit", false);
-  }
-  async __getThreadById({ threadId }) {
-    await this.init();
-    return this.getThreadById({
-      threadId
-    });
-  }
-  async __getThreadsByResourceId({ resourceId }) {
-    await this.init();
-    return this.getThreadsByResourceId({
-      resourceId
-    });
-  }
-  async __saveThread({ thread }) {
-    await this.init();
-    return this.saveThread({
-      thread
-    });
-  }
-  async __updateThread({ id, title, metadata }) {
-    await this.init();
-    return this.updateThread({
-      id,
-      title,
-      metadata
-    });
-  }
-  async __deleteThread({ threadId }) {
-    await this.init();
-    return this.deleteThread({
-      threadId
-    });
-  }
-  async __getMessages({ threadId, selectBy, threadConfig }) {
-    await this.init();
-    return this.getMessages({
-      threadId,
-      selectBy,
-      threadConfig
-    });
-  }
-  async __saveMessages({ messages }) {
-    await this.init();
-    return this.saveMessages({
-      messages
-    });
-  }
-  async init() {
-    if (this.hasInit) {
-      return;
-    }
-    await this.createTable({
-      tableName: _MastraStorage.TABLE_WORKFLOW_SNAPSHOT,
-      schema: {
-        workflow_name: {
-          type: "text"
-        },
-        run_id: {
-          type: "text"
-        },
-        snapshot: {
-          type: "text"
-        },
-        createdAt: {
-          type: "timestamp"
-        },
-        updatedAt: {
-          type: "timestamp"
-        }
-      }
-    });
-    await this.createTable({
-      tableName: _MastraStorage.TABLE_EVALS,
-      schema: {
-        meta: {
-          type: "text"
-        },
-        result: {
-          type: "text"
-        },
-        input: {
-          type: "text"
-        },
-        output: {
-          type: "text"
-        },
-        createdAt: {
-          type: "timestamp"
-        }
-      }
-    });
-    await this.createTable({
-      tableName: _MastraStorage.TABLE_THREADS,
-      schema: {
-        id: {
-          type: "text",
-          nullable: false,
-          primaryKey: true
-        },
-        resourceId: {
-          type: "text",
-          nullable: false
-        },
-        title: {
-          type: "text",
-          nullable: false
-        },
-        metadata: {
-          type: "text",
-          nullable: true
-        },
-        createdAt: {
-          type: "timestamp",
-          nullable: false
-        },
-        updatedAt: {
-          type: "timestamp",
-          nullable: false
-        }
-      }
-    });
-    await this.createTable({
-      tableName: _MastraStorage.TABLE_MESSAGES,
-      schema: {
-        id: {
-          type: "text",
-          nullable: false,
-          primaryKey: true
-        },
-        thread_id: {
-          type: "text",
-          nullable: false
-        },
-        content: {
-          type: "text",
-          nullable: false
-        },
-        role: {
-          type: "text",
-          nullable: false
-        },
-        type: {
-          type: "text",
-          nullable: false
-        },
-        createdAt: {
-          type: "timestamp",
-          nullable: false
-        }
-      }
-    });
-    this.hasInit = true;
-  }
-  async persistWorkflowSnapshot({ workflowName, runId, snapshot }) {
-    await this.init();
-    const data = {
-      workflow_name: workflowName,
-      run_id: runId,
-      snapshot,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.logger.debug("Persisting workflow snapshot", {
-      workflowName,
-      runId,
-      data
-    });
-    await this.insert({
-      tableName: _MastraStorage.TABLE_WORKFLOW_SNAPSHOT,
-      record: data
-    });
-  }
-  async loadWorkflowSnapshot({ workflowName, runId }) {
-    if (!this.hasInit) {
-      await this.init();
-    }
-    this.logger.debug("Loading workflow snapshot", {
-      workflowName,
-      runId
-    });
-    const d = await this.load({
-      tableName: _MastraStorage.TABLE_WORKFLOW_SNAPSHOT,
-      keys: {
-        workflow_name: workflowName,
-        run_id: runId
-      }
-    });
-    return d ? d.snapshot : null;
-  }
-};
-__name(_MastraStorage, "MastraStorage");
-__publicField(_MastraStorage, "TABLE_WORKFLOW_SNAPSHOT", "mastra_workflow_snapshot");
-__publicField(_MastraStorage, "TABLE_EVALS", "mastra_evals");
-__publicField(_MastraStorage, "TABLE_MESSAGES", "mastra_messages");
-__publicField(_MastraStorage, "TABLE_THREADS", "mastra_threads");
-var MastraStorage = _MastraStorage;
-var _DefaultStorage = class _DefaultStorage extends MastraStorage {
-  constructor({ config }) {
-    super({
-      name: `MastraStorageLibSql`
-    });
-    __publicField(this, "client");
-    this.client = createClient({
-      url: this.rewriteDbUrl(config.url),
-      authToken: config.authToken
-    });
-  }
-  rewriteDbUrl(url) {
-    if (url.startsWith("file:") && !url.startsWith("file:/")) {
-      const cwd = process.cwd();
-      const relativePath = url.slice("file:".length);
-      if (cwd.endsWith(".mastra") || cwd.endsWith(".mastra/")) {
-        const baseDir = join(cwd, `..`);
-        const fullPath = join(baseDir, relativePath);
-        this.logger.debug(`Initializing LibSQL db with url ${url} with relative file path from inside .mastra directory. Rewriting relative file url to "file:${fullPath}". This ensures it's outside the .mastra directory. If the db is stored inside .mastra it will be deleted when Mastra re-bundles code.`);
-        return `file:${fullPath}`;
-      }
-    }
-    return url;
-  }
-  getCreateTableSQL(tableName, schema) {
-    const columns = Object.entries(schema).map(([name, col]) => {
-      let type = col.type.toUpperCase();
-      if (type === "TEXT") type = "TEXT";
-      if (type === "TIMESTAMP") type = "TEXT";
-      const nullable = col.nullable ? "" : "NOT NULL";
-      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
-      return `${name} ${type} ${nullable} ${primaryKey}`.trim();
-    });
-    if (tableName === MastraStorage.TABLE_WORKFLOW_SNAPSHOT) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${tableName} (
-                ${columns.join(",\n")},
-                PRIMARY KEY (workflow_name, run_id)
-            )`;
-      this.logger.info(stmnt);
-      return stmnt;
-    }
-    return `CREATE TABLE IF NOT EXISTS ${tableName} (${columns.join(", ")})`;
-  }
-  async createTable({ tableName, schema }) {
-    try {
-      this.logger.debug(`Creating table ${tableName}`);
-      const sql = this.getCreateTableSQL(tableName, schema);
-      await this.client.execute(sql);
-    } catch (error) {
-      this.logger.error(`Error creating table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async clearTable({ tableName }) {
-    try {
-      await this.client.execute(`DELETE FROM ${tableName}`);
-    } catch (e) {
-      if (e instanceof Error) {
-        this.logger.error(e.message);
-      }
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const columns = Object.keys(record);
-      const values = Object.values(record).map((v) => {
-        if (typeof v === `undefined`) {
-          return null;
-        }
-        return typeof v === "object" ? JSON.stringify(v) : v;
-      });
-      const placeholders = values.map(() => "?").join(", ");
-      await this.client.execute({
-        sql: `INSERT OR REPLACE INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`,
-        args: values
-      });
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async load({ tableName, keys }) {
-    const conditions = Object.entries(keys).map(([key]) => `${key} = ?`).join(" AND ");
-    const values = Object.values(keys);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${tableName} WHERE ${conditions} LIMIT 1`,
-      args: values
-    });
-    if (!result.rows || result.rows.length === 0) {
-      return null;
-    }
-    const row = result.rows[0];
-    const parsed = Object.fromEntries(Object.entries(row || {}).map(([k, v]) => {
-      try {
-        return [
-          k,
-          typeof v === "string" ? JSON.parse(v) : v
-        ];
-      } catch {
-        return [
-          k,
-          v
-        ];
-      }
-    }));
-    return parsed;
-  }
-  async getThreadById({ threadId }) {
-    const result = await this.load({
-      tableName: MastraStorage.TABLE_THREADS,
-      keys: {
-        id: threadId
-      }
-    });
-    if (!result) {
-      return null;
-    }
-    return {
-      ...result,
-      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-    };
-  }
-  async getThreadsByResourceId({ resourceId }) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${MastraStorage.TABLE_THREADS} WHERE resourceId = ?`,
-      args: [
-        resourceId
-      ]
-    });
-    if (!result.rows) {
-      return [];
-    }
-    return result.rows.map((thread) => ({
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title,
-      createdAt: thread.createdAt,
-      updatedAt: thread.updatedAt,
-      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-    }));
-  }
-  async saveThread({ thread }) {
-    await this.insert({
-      tableName: MastraStorage.TABLE_THREADS,
-      record: {
-        ...thread,
-        metadata: JSON.stringify(thread.metadata)
-      }
-    });
-    return thread;
-  }
-  async updateThread({ id, title, metadata }) {
-    const thread = await this.getThreadById({
-      threadId: id
-    });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
-    }
-    const updatedThread = {
-      ...thread,
-      title,
-      metadata: {
-        ...thread.metadata,
-        ...metadata
-      }
-    };
-    await this.client.execute({
-      sql: `UPDATE ${MastraStorage.TABLE_THREADS} SET title = ?, metadata = ? WHERE id = ?`,
-      args: [
-        title,
-        JSON.stringify(updatedThread.metadata),
-        id
-      ]
-    });
-    return updatedThread;
-  }
-  async deleteThread({ threadId }) {
-    await this.client.execute({
-      sql: `DELETE FROM ${MastraStorage.TABLE_THREADS} WHERE id = ?`,
-      args: [
-        threadId
-      ]
-    });
-  }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch (e) {
-    }
-    return {
-      id: row.id,
-      content,
-      role: row.role,
-      type: row.type,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
-    };
-  }
-  async getMessages({ threadId, selectBy }) {
-    try {
-      const messages = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-      if (selectBy?.include?.length) {
-        const includeIds = selectBy.include.map((i) => i.id);
-        const maxPrev = Math.max(...selectBy.include.map((i) => i.withPreviousMessages || 0));
-        const maxNext = Math.max(...selectBy.include.map((i) => i.withNextMessages || 0));
-        const includeResult = await this.client.execute({
-          sql: `
-            WITH numbered_messages AS (
-              SELECT 
-                id,
-                content,
-                role,
-                type,
-                "createdAt",
-                thread_id,
-                ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
-              FROM "${MastraStorage.TABLE_MESSAGES}"
-              WHERE thread_id = ?
-            ),
-            target_positions AS (
-              SELECT row_num as target_pos
-              FROM numbered_messages
-              WHERE id IN (${includeIds.map(() => "?").join(", ")})
-            )
-            SELECT DISTINCT m.*
-            FROM numbered_messages m
-            CROSS JOIN target_positions t
-            WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
-            ORDER BY m."createdAt" ASC
-          `,
-          args: [
-            threadId,
-            ...includeIds,
-            maxPrev,
-            maxNext
-          ]
-        });
-        if (includeResult.rows) {
-          messages.push(...includeResult.rows.map((row) => this.parseRow(row)));
-        }
-      }
-      const excludeIds = messages.map((m) => m.id);
-      const remainingSql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id
-        FROM "${MastraStorage.TABLE_MESSAGES}"
-        WHERE thread_id = ?
-        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
-        ORDER BY "createdAt" DESC
-        LIMIT ?
-      `;
-      const remainingArgs = [
-        threadId,
-        ...excludeIds.length ? excludeIds : [],
-        limit
-      ];
-      const remainingResult = await this.client.execute({
-        sql: remainingSql,
-        args: remainingArgs
-      });
-      if (remainingResult.rows) {
-        messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
-      }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      return messages;
-    } catch (error) {
-      this.logger.error("Error getting messages:", error);
-      throw error;
-    }
-  }
-  async saveMessages({ messages }) {
-    if (messages.length === 0) return messages;
-    const tx = await this.client.transaction("write");
-    try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      for (const message of messages) {
-        const time = message.createdAt || /* @__PURE__ */ new Date();
-        await tx.execute({
-          sql: `INSERT INTO ${MastraStorage.TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt) 
-                              VALUES (?, ?, ?, ?, ?, ?)`,
-          args: [
-            message.id,
-            threadId,
-            typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
-            message.role,
-            message.type,
-            time instanceof Date ? time.toISOString() : time
-          ]
-        });
-      }
-      await tx.commit();
-      return messages;
-    } catch (error) {
-      console.error("Failed to save messages in database", error);
-      await tx.rollback();
-      throw error;
-    }
-  }
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const baseQuery = `SELECT * FROM ${MastraStorage.TABLE_EVALS} WHERE meta->>'$.agentName' = ?`;
-      const typeCondition = type === "test" ? " AND meta->>'$.testPath' IS NOT NULL" : type === "live" ? " AND meta->>'$.testPath' IS NULL" : "";
-      const result = await this.client.execute({
-        sql: `${baseQuery}${typeCondition} ORDER BY createdAt DESC`,
-        args: [
-          agentName
-        ]
-      });
-      if (!result.rows) {
-        return [];
-      }
-      return result.rows.map((row) => ({
-        ...row,
-        result: typeof row.result === "string" ? JSON.parse(row.result) : row.result,
-        meta: typeof row.meta === "string" ? JSON.parse(row.meta) : row.meta,
-        input: row.input,
-        output: row.output,
-        createdAt: row.createdAt
-      }));
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
-        return [];
-      }
-      console.error("Failed to get evals for the specified agent", error);
-      throw error;
-    }
-  }
-};
-__name(_DefaultStorage, "DefaultStorage");
-var DefaultStorage = _DefaultStorage;
-
-export { DefaultStorage, MastraStorage };