@mastra/core 0.9.4 → 0.9.5-alpha.0

package/dist/{chunk-EJITEVAB.cjs → chunk-F7HNPG53.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkLABUWBKX_cjs = require('./chunk-LABUWBKX.cjs');
 var chunkEG74VBSP_cjs = require('./chunk-EG74VBSP.cjs');
+var chunkLABUWBKX_cjs = require('./chunk-LABUWBKX.cjs');
 var crypto = require('crypto');
 var ai = require('ai');
 var jsonSchemaToZod = require('json-schema-to-zod');
@@ -951,6 +951,25 @@ ${JSON.stringify(message, null, 2)}
     );
   }).flat();
 }
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function parseSqlIdentifier(name, kind = "identifier") {
+  if (!SQL_IDENTIFIER_PATTERN.test(name) || name.length > 63) {
+    throw new Error(
+      `Invalid ${kind}: ${name}. Must start with a letter or underscore, contain only letters, numbers, or underscores, and be at most 63 characters long.`
+    );
+  }
+  return name;
+}
+function parseFieldKey(key) {
+  if (!key) throw new Error("Field key cannot be empty");
+  const segments = key.split(".");
+  for (const segment of segments) {
+    if (!SQL_IDENTIFIER_PATTERN.test(segment) || segment.length > 63) {
+      throw new Error(`Invalid field key segment: ${segment} in ${key}`);
+    }
+  }
+  return key;
+}
 
 exports.Tool = Tool;
 exports.checkEvalStorageFields = checkEvalStorageFields;
@@ -960,8 +979,12 @@ exports.deepMerge = deepMerge;
 exports.delay = delay;
 exports.ensureAllMessagesAreCoreMessages = ensureAllMessagesAreCoreMessages;
 exports.ensureToolProperties = ensureToolProperties;
+exports.isCoreMessage = isCoreMessage;
+exports.isUiMessage = isUiMessage;
 exports.isVercelTool = isVercelTool;
 exports.isZodType = isZodType;
 exports.makeCoreTool = makeCoreTool;
 exports.maskStreamTags = maskStreamTags;
+exports.parseFieldKey = parseFieldKey;
+exports.parseSqlIdentifier = parseSqlIdentifier;
 exports.resolveSerializedZodOutput = resolveSerializedZodOutput;

package/dist/{chunk-WE36CRQV.cjs → chunk-HKCSQI7G.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk66GQROSI_cjs = require('./chunk-66GQROSI.cjs');
+var chunkS3Y7QBO7_cjs = require('./chunk-S3Y7QBO7.cjs');
 var cohereAi = require('cohere-ai');
 
 var CohereRelevanceScorer = class {
@@ -38,7 +38,7 @@ Relevance score (0-1):`;
 var MastraAgentRelevanceScorer = class {
   agent;
   constructor(name, model) {
-    this.agent = new chunk66GQROSI_cjs.Agent({
+    this.agent = new chunkS3Y7QBO7_cjs.Agent({
       name: `Relevance Scorer ${name}`,
       instructions: `You are a specialized agent for evaluating the relevance of text to queries.
 Your task is to rate how well a text passage answers a given query.

package/dist/{chunk-4WABQORE.js → chunk-JMJXBE7L.js}

@@ -1,5 +1,6 @@
-import { MastraVector } from './chunk-NZV4OA6P.js';
+import { MastraVector } from './chunk-SU4O2A72.js';
 import { BaseFilterTranslator } from './chunk-LGERQTJM.js';
+import { parseSqlIdentifier, parseFieldKey } from './chunk-MF5BUJO6.js';
 import { isAbsolute, join, resolve } from 'path';
 import { createClient } from '@libsql/client';
 
@@ -73,44 +74,52 @@ var LibSQLFilterTranslator = class extends BaseFilterTranslator {
 
 // src/vector/libsql/sql-builder.ts
 var createBasicOperator = (symbol) => {
-  return (key, value) => ({
-    sql: `CASE 
-      WHEN ? IS NULL THEN json_extract(metadata, '$."${handleKey(key)}"') IS ${symbol === "=" ? "" : "NOT"} NULL
-      ELSE json_extract(metadata, '$."${handleKey(key)}"') ${symbol} ?
-    END`,
-    needsValue: true,
-    transformValue: () => [value, value]
-  });
+  return (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `CASE 
+        WHEN ? IS NULL THEN json_extract(metadata, '$."${jsonPathKey}"') IS ${symbol === "=" ? "" : "NOT"} NULL
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') ${symbol} ?
+      END`,
+      needsValue: true,
+      transformValue: () => {
+        return [value, value];
+      }
+    };
+  };
 };
 var createNumericOperator = (symbol) => {
-  return (key) => ({
-    sql: `CAST(json_extract(metadata, '$."${handleKey(key)}"') AS NUMERIC) ${symbol} ?`,
-    needsValue: true
-  });
+  return (key) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `CAST(json_extract(metadata, '$."${jsonPathKey}"') AS NUMERIC) ${symbol} ?`,
+      needsValue: true
+    };
+  };
 };
+var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${key}"'))
+   AND json_type(json_extract(metadata, '$."${key}"')) = 'array'`;
+var pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
 function buildElemMatchConditions(value) {
   const conditions = Object.entries(value).map(([field, fieldValue]) => {
     if (field.startsWith("$")) {
       const { sql, values } = buildCondition("elem.value", { [field]: fieldValue });
-      const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
       const elemSql = sql.replace(pattern, "elem.value");
       return { sql: elemSql, values };
     } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
       const { sql, values } = buildCondition(field, fieldValue);
-      const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
       const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
       return { sql: elemSql, values };
     } else {
+      const parsedFieldKey = parseFieldKey(field);
       return {
-        sql: `json_extract(elem.value, '$."${field}"') = ?`,
+        sql: `json_extract(elem.value, '$."${parsedFieldKey}"') = ?`,
         values: [fieldValue]
       };
     }
   });
   return conditions;
 }
-var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
-   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`;
 var FILTER_OPERATORS = {
   $eq: createBasicOperator("="),
   $ne: createBasicOperator("!="),
@@ -120,6 +129,7 @@ var FILTER_OPERATORS = {
   $lte: createNumericOperator("<="),
   // Array Operators
   $in: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
     const arr = Array.isArray(value) ? value : [value];
     if (arr.length === 0) {
       return { sql: "1 = 0", needsValue: true, transformValue: () => [] };
@@ -128,12 +138,12 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
       CASE
-        WHEN ${validateJsonArray(key)} THEN
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
           EXISTS (
-            SELECT 1 FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
+            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
             WHERE elem.value IN (SELECT value FROM json_each(?))
           )
-        ELSE json_extract(metadata, '$."${handleKey(key)}"') IN (${paramPlaceholders})
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') IN (${paramPlaceholders})
       END
     )`,
       needsValue: true,
@@ -141,6 +151,7 @@ var FILTER_OPERATORS = {
     };
   },
   $nin: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
     const arr = Array.isArray(value) ? value : [value];
     if (arr.length === 0) {
       return { sql: "1 = 1", needsValue: true, transformValue: () => [] };
@@ -149,12 +160,12 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
       CASE
-        WHEN ${validateJsonArray(key)} THEN
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
           NOT EXISTS (
-            SELECT 1 FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
+            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
             WHERE elem.value IN (SELECT value FROM json_each(?))
           )
-        ELSE json_extract(metadata, '$."${handleKey(key)}"') NOT IN (${paramPlaceholders})
+        ELSE json_extract(metadata, '$."${jsonPathKey}"') NOT IN (${paramPlaceholders})
       END
     )`,
       needsValue: true,
@@ -162,6 +173,7 @@ var FILTER_OPERATORS = {
     };
   },
   $all: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
     let sql;
     const arrayValue = Array.isArray(value) ? value : [value];
     if (arrayValue.length === 0) {
@@ -169,13 +181,13 @@ var FILTER_OPERATORS = {
     } else {
       sql = `(
       CASE
-        WHEN ${validateJsonArray(key)} THEN
+        WHEN ${validateJsonArray(jsonPathKey)} THEN
           NOT EXISTS (
             SELECT value
             FROM json_each(?)
             WHERE value NOT IN (
               SELECT value
-              FROM json_each(json_extract(metadata, '$."${handleKey(key)}"'))
+              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"'))
             )
           )
         ELSE FALSE
@@ -194,6 +206,7 @@ var FILTER_OPERATORS = {
     };
   },
   $elemMatch: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
     if (typeof value !== "object" || Array.isArray(value)) {
       throw new Error("$elemMatch requires an object with conditions");
     }
@@ -201,10 +214,10 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
         CASE
-          WHEN ${validateJsonArray(key)} THEN
+          WHEN ${validateJsonArray(jsonPathKey)} THEN
             EXISTS (
               SELECT 1
-              FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
+              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
               WHERE ${conditions.map((c) => c.sql).join(" AND ")}
             )
           ELSE FALSE
@@ -215,10 +228,13 @@ var FILTER_OPERATORS = {
     };
   },
   // Element Operators
-  $exists: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') IS NOT NULL`,
-    needsValue: false
-  }),
+  $exists: (key) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `json_extract(metadata, '$."${jsonPathKey}"') IS NOT NULL`,
+      needsValue: false
+    };
+  },
   // Logical Operators
   $and: (key) => ({
     sql: `(${key})`,
@@ -233,27 +249,30 @@ var FILTER_OPERATORS = {
     sql: `NOT (${key})`,
     needsValue: false
   }),
-  $size: (key, paramIndex) => ({
-    sql: `(
+  $size: (key, paramIndex) => {
+    const jsonPathKey = parseJsonPathKey(key);
+    return {
+      sql: `(
     CASE
-      WHEN json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array' THEN 
-        json_array_length(json_extract(metadata, '$."${handleKey(key)}"')) = $${paramIndex}
+      WHEN json_type(json_extract(metadata, '$."${jsonPathKey}"')) = 'array' THEN 
+        json_array_length(json_extract(metadata, '$."${jsonPathKey}"')) = $${paramIndex}
       ELSE FALSE
     END
   )`,
-    needsValue: true
-  }),
+      needsValue: true
+    };
+  },
   //   /**
   //    * Regex Operators
   //    * Supports case insensitive and multiline
   //    */
   //   $regex: (key: string): FilterOperator => ({
-  //     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
+  //     sql: `json_extract(metadata, '$."${toJsonPathKey(key)}"') = ?`,
   //     needsValue: true,
   //     transformValue: (value: any) => {
   //       const pattern = typeof value === 'object' ? value.$regex : value;
   //       const options = typeof value === 'object' ? value.$options || '' : '';
-  //       let sql = `json_extract(metadata, '$."${handleKey(key)}"')`;
+  //       let sql = `json_extract(metadata, '$."${toJsonPathKey(key)}"')`;
   //       // Handle multiline
   //       //   if (options.includes('m')) {
   //       //     sql = `REPLACE(${sql}, CHAR(10), '\n')`;
@@ -303,20 +322,21 @@ var FILTER_OPERATORS = {
   //     },
   //   }),
   $contains: (key, value) => {
+    const jsonPathKey = parseJsonPathKey(key);
     let sql;
     if (Array.isArray(value)) {
       sql = `(
-        SELECT ${validateJsonArray(key)}
+        SELECT ${validateJsonArray(jsonPathKey)}
         AND EXISTS (
           SELECT 1
-          FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as m
+          FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as m
           WHERE m.value IN (SELECT value FROM json_each(?))
         )
       )`;
     } else if (typeof value === "string") {
-      sql = `lower(json_extract(metadata, '$."${handleKey(key)}"')) LIKE '%' || lower(?) || '%'`;
+      sql = `lower(json_extract(metadata, '$."${jsonPathKey}"')) LIKE '%' || lower(?) || '%' ESCAPE '\\'`;
     } else {
-      sql = `json_extract(metadata, '$."${handleKey(key)}"') = ?`;
+      sql = `json_extract(metadata, '$."${jsonPathKey}"') = ?`;
     }
     return {
       sql,
@@ -328,6 +348,9 @@ var FILTER_OPERATORS = {
         if (typeof value === "object" && value !== null) {
           return [JSON.stringify(value)];
         }
+        if (typeof value === "string") {
+          return [escapeLikePattern(value)];
+        }
         return [value];
       }
     };
@@ -340,15 +363,22 @@ var FILTER_OPERATORS = {
   //   sql: '', // Will be overridden by transformValue
   //   needsValue: true,
   //   transformValue: (value: any) => ({
-  //     sql: `json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'object'
-  //         AND json_patch(json_extract(metadata, '$."${handleKey(key)}"'), ?) = json_extract(metadata, '$."${handleKey(key)}"')`,
+  //     sql: `json_type(json_extract(metadata, '$."${toJsonPathKey(key)}"')) = 'object'
+  //         AND json_patch(json_extract(metadata, '$."${toJsonPathKey(key)}"'), ?) = json_extract(metadata, '$."${toJsonPathKey(key)}"')`,
   //     values: [JSON.stringify(value)],
   //   }),
   // }),
 };
-var handleKey = (key) => {
-  return key.replace(/\./g, '"."');
+function isFilterResult(obj) {
+  return obj && typeof obj === "object" && typeof obj.sql === "string" && Array.isArray(obj.values);
+}
+var parseJsonPathKey = (key) => {
+  const parsedKey = parseFieldKey(key);
+  return parsedKey.replace(/\./g, '"."');
 };
+function escapeLikePattern(str) {
+  return str.replace(/([%_\\])/g, "\\$1");
+}
 function buildFilterQuery(filter) {
   if (!filter) {
     return { sql: "", values: [] };
@@ -442,6 +472,9 @@ var processOperator = (key, operator, operatorValue) => {
     return { sql: operatorResult.sql, values: [] };
   }
   const transformed = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
+  if (isFilterResult(transformed)) {
+    return transformed;
+  }
   return {
     sql: operatorResult.sql,
     values: Array.isArray(transformed) ? transformed : [transformed]
@@ -508,10 +541,18 @@ var LibSQLVector = class extends MastraVector {
     const params = this.normalizeArgs("query", args, ["minScore"]);
     try {
       const { indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0 } = params;
+      if (!Number.isInteger(topK) || topK <= 0) {
+        throw new Error("topK must be a positive integer");
+      }
+      if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error("queryVector must be an array of finite numbers");
+      }
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const vectorStr = `[${queryVector.join(",")}]`;
       const translatedFilter = this.transformFilter(filter);
       const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
       filterValues.push(minScore);
+      filterValues.push(topK);
       const query = `
         WITH vector_scores AS (
           SELECT
@@ -519,14 +560,14 @@ var LibSQLVector = class extends MastraVector {
             (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
             metadata
             ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
-          FROM ${indexName}
+          FROM ${parsedIndexName}
           ${filterQuery}
         )
         SELECT *
         FROM vector_scores
         WHERE score > ?
         ORDER BY score DESC
-        LIMIT ${topK}`;
+        LIMIT ?`;
       const result = await this.turso.execute({
         sql: query,
         args: filterValues
@@ -545,10 +586,11 @@ var LibSQLVector = class extends MastraVector {
     const { indexName, vectors, metadata, ids } = params;
     const tx = await this.turso.transaction("write");
     try {
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       for (let i = 0; i < vectors.length; i++) {
         const query = `
-          INSERT INTO ${indexName} (vector_id, embedding, metadata)
+          INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
           VALUES (?, vector32(?), ?)
           ON CONFLICT(vector_id) DO UPDATE SET
             embedding = vector32(?),
@@ -586,15 +628,13 @@ var LibSQLVector = class extends MastraVector {
     const params = this.normalizeArgs("createIndex", args);
     const { indexName, dimension } = params;
     try {
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error("Invalid index name format");
-      }
       if (!Number.isInteger(dimension) || dimension <= 0) {
         throw new Error("Dimension must be a positive integer");
       }
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
         sql: `
-        CREATE TABLE IF NOT EXISTS ${indexName} (
+        CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
           id SERIAL PRIMARY KEY,
           vector_id TEXT UNIQUE NOT NULL,
           embedding F32_BLOB(${dimension}),
@@ -605,8 +645,8 @@ var LibSQLVector = class extends MastraVector {
       });
       await this.turso.execute({
         sql: `
-        CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
-        ON ${indexName} (libsql_vector_idx(embedding))
+        CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
+        ON ${parsedIndexName} (libsql_vector_idx(embedding))
       `,
         args: []
       });
@@ -616,10 +656,13 @@ var LibSQLVector = class extends MastraVector {
     } finally {
     }
   }
-  async deleteIndex(indexName) {
+  async deleteIndex(...args) {
+    const params = this.normalizeArgs("deleteIndex", args);
+    const { indexName } = params;
     try {
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
-        sql: `DROP TABLE IF EXISTS ${indexName}`,
+        sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
         args: []
       });
     } catch (error) {
@@ -644,8 +687,17 @@ var LibSQLVector = class extends MastraVector {
       throw new Error(`Failed to list vector tables: ${error.message}`);
     }
   }
-  async describeIndex(indexName) {
+  /**
+   * Retrieves statistics about a vector index.
+   *
+   * @param params - The parameters for describing an index
+   * @param params.indexName - The name of the index to describe
+   * @returns A promise that resolves to the index statistics including dimension, count and metric
+   */
+  async describeIndex(...args) {
     try {
+      const { indexName } = this.normalizeArgs("describeIndex", args);
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const tableInfoQuery = `
         SELECT sql 
         FROM sqlite_master 
@@ -654,15 +706,15 @@ var LibSQLVector = class extends MastraVector {
       `;
       const tableInfo = await this.turso.execute({
         sql: tableInfoQuery,
-        args: [indexName]
+        args: [parsedIndexName]
       });
       if (!tableInfo.rows[0]?.sql) {
-        throw new Error(`Table ${indexName} not found`);
+        throw new Error(`Table ${parsedIndexName} not found`);
       }
       const dimension = parseInt(tableInfo.rows[0].sql.match(/F32_BLOB\((\d+)\)/)?.[1] || "0");
       const countQuery = `
         SELECT COUNT(*) as count
-        FROM ${indexName};
+        FROM ${parsedIndexName};
       `;
       const countResult = await this.turso.execute({
         sql: countQuery,
@@ -692,9 +744,11 @@ var LibSQLVector = class extends MastraVector {
    */
   async updateIndexById(indexName, id, update) {
     this.logger.warn(
-      `Deprecation Warning: updateIndexById() is deprecated. Please use updateVector() instead. updateIndexById() will be removed on May 20th, 2025.`
+      `Deprecation Warning: updateIndexById() is deprecated. 
+      Please use updateVector() instead. 
+      updateIndexById() will be removed on May 20th, 2025.`
     );
-    await this.updateVector(indexName, id, update);
+    await this.updateVector({ indexName, id, update });
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -707,30 +761,33 @@ var LibSQLVector = class extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector(indexName, id, update) {
+  async updateVector(...args) {
+    const params = this.normalizeArgs("updateVector", args);
+    const { indexName, id, update } = params;
     try {
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const updates = [];
-      const args = [];
+      const args2 = [];
       if (update.vector) {
         updates.push("embedding = vector32(?)");
-        args.push(JSON.stringify(update.vector));
+        args2.push(JSON.stringify(update.vector));
       }
       if (update.metadata) {
         updates.push("metadata = ?");
-        args.push(JSON.stringify(update.metadata));
+        args2.push(JSON.stringify(update.metadata));
       }
       if (updates.length === 0) {
         throw new Error("No updates provided");
       }
-      args.push(id);
+      args2.push(id);
       const query = `
-        UPDATE ${indexName}
+        UPDATE ${parsedIndexName}
         SET ${updates.join(", ")}
         WHERE vector_id = ?;
       `;
       await this.turso.execute({
         sql: query,
-        args
+        args: args2
       });
     } catch (error) {
       throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
@@ -751,7 +808,7 @@ var LibSQLVector = class extends MastraVector {
       Please use deleteVector() instead. 
       deleteIndexById() will be removed on May 20th, 2025.`
     );
-    await this.deleteVector(indexName, id);
+    await this.deleteVector({ indexName, id });
   }
   /**
    * Deletes a vector by its ID.
@@ -760,19 +817,24 @@ var LibSQLVector = class extends MastraVector {
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector(indexName, id) {
+  async deleteVector(...args) {
+    const params = this.normalizeArgs("deleteVector", args);
+    const { indexName, id } = params;
     try {
+      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       await this.turso.execute({
-        sql: `DELETE FROM ${indexName} WHERE vector_id = ?`,
+        sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
         args: [id]
       });
     } catch (error) {
       throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
     }
   }
-  async truncateIndex(indexName) {
+  async truncateIndex(...args) {
+    const params = this.normalizeArgs("truncateIndex", args);
+    const { indexName } = params;
     await this.turso.execute({
-      sql: `DELETE FROM ${indexName}`,
+      sql: `DELETE FROM ${parseSqlIdentifier(indexName, "index name")}`,
       args: []
     });
   }

package/dist/{chunk-5JUWUTPJ.cjs → chunk-LF5CE7LU.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkEJITEVAB_cjs = require('./chunk-EJITEVAB.cjs');
+var chunkF7HNPG53_cjs = require('./chunk-F7HNPG53.cjs');
 var zod = require('zod');
 
 // src/integration/integration.ts
@@ -68,7 +68,7 @@ var OpenAPIToolset = class {
     const tools = Object.keys(clientMethods).reduce((acc, key) => {
       const comment = documentations[key]?.comment;
       const fallbackComment = `Execute ${key}`;
-      const tool = chunkEJITEVAB_cjs.createTool({
+      const tool = chunkF7HNPG53_cjs.createTool({
         id: key,
         inputSchema: schemas[key] || zod.z.object({}),
         description: comment || fallbackComment,

package/dist/{chunk-S34QVMKE.js → chunk-MF5BUJO6.js}

@@ -1,5 +1,5 @@
-import { RuntimeContext } from './chunk-SGGPJWRQ.js';
 import { MastraBase } from './chunk-235X76GC.js';
+import { RuntimeContext } from './chunk-SGGPJWRQ.js';
 import { createHash } from 'crypto';
 import { convertToCoreMessages, jsonSchema, zodSchema } from 'ai';
 import jsonSchemaToZod from 'json-schema-to-zod';
@@ -945,5 +945,24 @@ ${JSON.stringify(message, null, 2)}
     );
   }).flat();
 }
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function parseSqlIdentifier(name, kind = "identifier") {
+  if (!SQL_IDENTIFIER_PATTERN.test(name) || name.length > 63) {
+    throw new Error(
+      `Invalid ${kind}: ${name}. Must start with a letter or underscore, contain only letters, numbers, or underscores, and be at most 63 characters long.`
+    );
+  }
+  return name;
+}
+function parseFieldKey(key) {
+  if (!key) throw new Error("Field key cannot be empty");
+  const segments = key.split(".");
+  for (const segment of segments) {
+    if (!SQL_IDENTIFIER_PATTERN.test(segment) || segment.length > 63) {
+      throw new Error(`Invalid field key segment: ${segment} in ${key}`);
+    }
+  }
+  return key;
+}
 
-export { Tool, checkEvalStorageFields, createMastraProxy, createTool, deepMerge, delay, ensureAllMessagesAreCoreMessages, ensureToolProperties, isVercelTool, isZodType, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };
+export { Tool, checkEvalStorageFields, createMastraProxy, createTool, deepMerge, delay, ensureAllMessagesAreCoreMessages, ensureToolProperties, isCoreMessage, isUiMessage, isVercelTool, isZodType, makeCoreTool, maskStreamTags, parseFieldKey, parseSqlIdentifier, resolveSerializedZodOutput };

package/dist/{chunk-WQKOM7XM.cjs → chunk-NQE264UM.cjs}

@@ -34,7 +34,7 @@ var MastraVector = class extends chunkEG74VBSP_cjs.MastraBase {
   async validateExistingIndex(indexName, dimension, metric) {
     let info;
     try {
-      info = await this.describeIndex(indexName);
+      info = await this.describeIndex({ indexName });
     } catch (infoError) {
       const message = `Index "${indexName}" already exists, but failed to fetch index info for dimension check: ${infoError}`;
       this.logger?.error(message);

package/dist/{chunk-PEK4TY3P.js → chunk-PU2TNRKO.js}

@@ -1,4 +1,4 @@
-import { createTool } from './chunk-S34QVMKE.js';
+import { createTool } from './chunk-MF5BUJO6.js';
 import { z } from 'zod';
 
 // src/integration/integration.ts