@mastra/dsql 0.0.0-ag-example-20260516005230

package/dist/index.cjs

@@ -0,0 +1,4478 @@
+'use strict';
+
+var auroraDsqlNodePostgresConnector = require('@aws/aurora-dsql-node-postgres-connector');
+var error = require('@mastra/core/error');
+var storage = require('@mastra/core/storage');
+var pg = require('pg');
+var base = require('@mastra/core/base');
+var utils = require('@mastra/core/utils');
+var agent = require('@mastra/core/agent');
+var evals = require('@mastra/core/evals');
+
+// src/storage/index.ts
+
+// src/shared/config.ts
+var DSQL_POOL_DEFAULTS = {
+  /** Maximum connections in the pool */
+  max: 10,
+  /** Minimum connections in the pool */
+  min: 0,
+  /** Close idle connections after 10 minutes */
+  idleTimeoutMillis: 6e5,
+  /** Force connection rotation before DSQL's 60-minute limit */
+  maxLifetimeSeconds: 3300,
+  /** Connection acquisition timeout */
+  connectionTimeoutMillis: 5e3,
+  /** Allow process to exit when idle */
+  allowExitOnIdle: true
+};
+var isPoolConfig = (cfg) => {
+  return "pool" in cfg;
+};
+var isHostConfig = (cfg) => {
+  return "host" in cfg;
+};
+var validateConfig = (config) => {
+  if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
+    throw new Error("DSQLStore: id must be provided and cannot be empty.");
+  }
+  if (isPoolConfig(config)) {
+    if (!config.pool) {
+      throw new Error("DSQLStore: pool must be provided when using pool config.");
+    }
+    return;
+  }
+  if (!isHostConfig(config)) {
+    throw new Error("DSQLStore: host must be provided and cannot be empty.");
+  }
+  if (!config.host || config.host.trim() === "") {
+    throw new Error("DSQLStore: host must be provided and cannot be empty.");
+  }
+  if (config.maxLifetimeSeconds !== void 0 && config.maxLifetimeSeconds >= 3600) {
+    throw new Error(
+      "DSQLStore: maxLifetimeSeconds must be less than 3600 (60 minutes) due to Aurora DSQL connection duration limit."
+    );
+  }
+};
+var extractRegionFromHost = (host) => {
+  const match = host.match(/\.dsql\.([a-z0-9-]+)\.on\.aws$/);
+  return match?.[1];
+};
+var getEffectiveRegion = (config) => {
+  if (config.region) {
+    return config.region;
+  }
+  const extractedRegion = extractRegionFromHost(config.host);
+  if (extractedRegion) {
+    return extractedRegion;
+  }
+  throw new Error(
+    "DSQLStore: region could not be determined. Provide region in config or use a standard DSQL endpoint."
+  );
+};
+
+// src/storage/client.ts
+function truncateQuery(query, maxLength = 100) {
+  const normalized = query.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return normalized.slice(0, maxLength) + "...";
+}
+var PoolAdapter = class {
+  constructor($pool) {
+    this.$pool = $pool;
+  }
+  $pool;
+  connect() {
+    return this.$pool.connect();
+  }
+  async none(query, values) {
+    await this.$pool.query(query, values);
+    return null;
+  }
+  async one(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async oneOrNone(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      return null;
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one or none was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async any(query, values) {
+    const result = await this.$pool.query(query, values);
+    return result.rows;
+  }
+  async manyOrNone(query, values) {
+    return this.any(query, values);
+  }
+  async many(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    return result.rows;
+  }
+  async query(query, values) {
+    return this.$pool.query(query, values);
+  }
+  async tx(callback) {
+    const client = await this.$pool.connect();
+    try {
+      await client.query("BEGIN");
+      const txClient = new TransactionClient(client);
+      const result = await callback(txClient);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        await client.query("ROLLBACK");
+      } catch (rollbackError) {
+        console.error("Transaction rollback failed:", rollbackError);
+      }
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+};
+var TransactionClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async none(query, values) {
+    await this.client.query(query, values);
+    return null;
+  }
+  async one(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async oneOrNone(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      return null;
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one or none was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async any(query, values) {
+    const result = await this.client.query(query, values);
+    return result.rows;
+  }
+  async manyOrNone(query, values) {
+    return this.any(query, values);
+  }
+  async many(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    return result.rows;
+  }
+  async query(query, values) {
+    return this.client.query(query, values);
+  }
+  async batch(promises) {
+    return Promise.all(promises);
+  }
+};
+
+// src/shared/retry.ts
+var RETRIABLE_ERROR_CODES = {
+  /** Serialization failure - OCC conflict in Aurora DSQL (default retriable) */
+  SERIALIZATION_FAILURE: "40001"};
+var DEFAULT_RETRIABLE_SQLSTATES = /* @__PURE__ */ new Set([RETRIABLE_ERROR_CODES.SERIALIZATION_FAILURE]);
+var DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 5,
+  initialDelayMs: 100,
+  maxDelayMs: 2e3,
+  backoffMultiplier: 2,
+  jitter: true
+};
+function isPostgresError(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string";
+}
+function getErrorCode(error) {
+  if (isPostgresError(error)) {
+    return error.code;
+  }
+  return void 0;
+}
+var SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+function getPostgresSqlStateCode(error) {
+  const raw = getErrorCode(error);
+  if (!raw) return void 0;
+  const code = raw.toUpperCase();
+  if (SQLSTATE_PATTERN.test(code)) {
+    return code;
+  }
+  return void 0;
+}
+function isRetriableError(error) {
+  const sqlstate = getPostgresSqlStateCode(error);
+  if (!sqlstate) {
+    return false;
+  }
+  return DEFAULT_RETRIABLE_SQLSTATES.has(sqlstate);
+}
+function calculateRetryDelay(attempt, options = {}) {
+  const {
+    initialDelayMs = DEFAULT_RETRY_OPTIONS.initialDelayMs,
+    maxDelayMs = DEFAULT_RETRY_OPTIONS.maxDelayMs,
+    backoffMultiplier = DEFAULT_RETRY_OPTIONS.backoffMultiplier,
+    jitter = DEFAULT_RETRY_OPTIONS.jitter
+  } = options;
+  const baseDelay = initialDelayMs * Math.pow(backoffMultiplier, attempt - 1);
+  const cappedDelay = Math.min(baseDelay, maxDelayMs);
+  if (jitter) {
+    return Math.floor(Math.random() * (cappedDelay + 1));
+  }
+  return cappedDelay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function validateRetryOptions(options) {
+  const { maxAttempts, initialDelayMs, maxDelayMs, backoffMultiplier } = options;
+  if (maxAttempts < 1) {
+    throw new Error(`Invalid retry option: maxAttempts must be >= 1, got ${maxAttempts}`);
+  }
+  if (initialDelayMs < 0) {
+    throw new Error(`Invalid retry option: initialDelayMs must be >= 0, got ${initialDelayMs}`);
+  }
+  if (maxDelayMs <= 0) {
+    throw new Error(`Invalid retry option: maxDelayMs must be > 0, got ${maxDelayMs}`);
+  }
+  if (backoffMultiplier < 1) {
+    throw new Error(`Invalid retry option: backoffMultiplier must be >= 1, got ${backoffMultiplier}`);
+  }
+  if (maxDelayMs < initialDelayMs) {
+    throw new Error(`Invalid retry option: maxDelayMs (${maxDelayMs}) must be >= initialDelayMs (${initialDelayMs})`);
+  }
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = DEFAULT_RETRY_OPTIONS.maxAttempts,
+    initialDelayMs = DEFAULT_RETRY_OPTIONS.initialDelayMs,
+    maxDelayMs = DEFAULT_RETRY_OPTIONS.maxDelayMs,
+    backoffMultiplier = DEFAULT_RETRY_OPTIONS.backoffMultiplier,
+    jitter = DEFAULT_RETRY_OPTIONS.jitter,
+    onRetry,
+    isRetriable = isRetriableError
+  } = options;
+  validateRetryOptions({ maxAttempts, initialDelayMs, maxDelayMs, backoffMultiplier });
+  const startTime = Date.now();
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const result = await fn();
+      return {
+        result,
+        attempts: attempt,
+        totalTimeMs: Date.now() - startTime
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxAttempts || !isRetriable(error)) {
+        throw lastError;
+      }
+      const delay = calculateRetryDelay(attempt, {
+        initialDelayMs,
+        maxDelayMs,
+        backoffMultiplier,
+        jitter
+      });
+      if (onRetry) {
+        onRetry(lastError, attempt, delay);
+      }
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+// src/shared/batch.ts
+var DEFAULT_MAX_ROWS_PER_BATCH = 3e3;
+function splitIntoBatches(records, options = {}) {
+  const maxRows = options.maxRows ?? DEFAULT_MAX_ROWS_PER_BATCH;
+  if (records.length === 0) {
+    return {
+      batches: [],
+      totalRecords: 0,
+      batchCount: 0
+    };
+  }
+  if (maxRows <= 0) {
+    throw new Error(`maxRows must be a positive number, got: ${maxRows}`);
+  }
+  const batches = [];
+  for (let i = 0; i < records.length; i += maxRows) {
+    batches.push(records.slice(i, i + maxRows));
+  }
+  return {
+    batches,
+    totalRecords: records.length,
+    batchCount: batches.length
+  };
+}
+
+// src/storage/db/index.ts
+function resolveDsqlConfig(config) {
+  if ("client" in config) {
+    return {
+      client: config.client,
+      schemaName: config.schemaName,
+      skipDefaultIndexes: config.skipDefaultIndexes,
+      indexes: config.indexes
+    };
+  }
+  if ("pool" in config) {
+    return {
+      client: new PoolAdapter(config.pool),
+      schemaName: config.schemaName,
+      skipDefaultIndexes: config.skipDefaultIndexes,
+      indexes: config.indexes
+    };
+  }
+  const pool = new pg.Pool({
+    host: config.host,
+    database: config.database,
+    user: config.user,
+    Client: auroraDsqlNodePostgresConnector.AuroraDSQLClient
+  });
+  return {
+    client: new PoolAdapter(pool),
+    schemaName: config.schemaName,
+    skipDefaultIndexes: config.skipDefaultIndexes,
+    indexes: config.indexes
+  };
+}
+function getSchemaName(schema) {
+  return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : '"public"';
+}
+function getTableName({ indexName, schemaName }) {
+  const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+  const quotedIndexName = `"${parsedIndexName}"`;
+  const quotedSchemaName = schemaName;
+  return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
+}
+var schemaSetupRegistry = /* @__PURE__ */ new Map();
+var DsqlDB = class extends base.MastraBase {
+  client;
+  schemaName;
+  skipDefaultIndexes;
+  constructor(config) {
+    super({
+      component: "STORAGE",
+      name: "DSQL_DB_LAYER"
+    });
+    this.client = config.client;
+    this.schemaName = config.schemaName;
+    this.skipDefaultIndexes = config.skipDefaultIndexes;
+  }
+  async hasColumn(table, column) {
+    const schema = this.schemaName || "public";
+    const result = await this.client.oneOrNone(
+      `SELECT 1 FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND (column_name = $3 OR column_name = $4)`,
+      [schema, table, column, column.toLowerCase()]
+    );
+    return !!result;
+  }
+  /**
+   * Prepares values for insertion, handling TEXT columns storing JSON by stringifying them.
+   * Aurora DSQL does not support JSONB natively, so we store JSON as TEXT.
+   */
+  prepareValuesForInsert(record, tableName) {
+    return Object.entries(record).map(([key, value]) => {
+      const schema = storage.TABLE_SCHEMAS[tableName];
+      const columnSchema = schema?.[key];
+      if (columnSchema?.type === "jsonb" && value !== null && value !== void 0 && typeof value === "object") {
+        return JSON.stringify(value);
+      }
+      return value;
+    });
+  }
+  /**
+   * Adds timestamp Z columns to a record if timestamp columns exist
+   */
+  addTimestampZColumns(record) {
+    if (record.createdAt) {
+      record.createdAtZ = record.createdAt;
+    }
+    if (record.created_at) {
+      record.created_atZ = record.created_at;
+    }
+    if (record.updatedAt) {
+      record.updatedAtZ = record.updatedAt;
+    }
+  }
+  /**
+   * Prepares a value for database operations, handling Date objects and JSON serialization.
+   * This is schema-aware and stringifies objects for TEXT columns storing JSON.
+   * Aurora DSQL: We use TEXT instead of JSONB and cast to ::jsonb when filtering.
+   */
+  prepareValue(value, columnName, tableName) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    const schema = storage.TABLE_SCHEMAS[tableName];
+    const columnSchema = schema?.[columnName];
+    if (columnSchema?.type === "jsonb") {
+      if (typeof value === "object") {
+        return JSON.stringify(value);
+      }
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  async setupSchema() {
+    if (!this.schemaName) {
+      return;
+    }
+    let registryEntry = schemaSetupRegistry.get(this.schemaName);
+    if (registryEntry?.complete) {
+      return;
+    }
+    const quotedSchemaName = getSchemaName(this.schemaName);
+    if (!registryEntry?.promise) {
+      const schemaNameCapture = this.schemaName;
+      const setupPromise = (async () => {
+        try {
+          const schemaExists = await this.client.oneOrNone(
+            `
+                SELECT EXISTS (
+                  SELECT 1 FROM information_schema.schemata
+                  WHERE schema_name = $1
+                )
+              `,
+            [schemaNameCapture]
+          );
+          if (!schemaExists?.exists) {
+            try {
+              await this.client.none(`CREATE SCHEMA IF NOT EXISTS ${quotedSchemaName}`);
+              this.logger.info(`Schema "${schemaNameCapture}" created successfully`);
+            } catch (error) {
+              this.logger.error(`Failed to create schema "${schemaNameCapture}"`, { error });
+              throw new Error(
+                `Unable to create schema "${schemaNameCapture}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
+              );
+            }
+          }
+          const entry = schemaSetupRegistry.get(schemaNameCapture);
+          if (entry) {
+            entry.complete = true;
+          }
+          this.logger.debug(`Schema "${quotedSchemaName}" is ready for use`);
+        } catch (error) {
+          schemaSetupRegistry.delete(schemaNameCapture);
+          throw error;
+        }
+      })();
+      schemaSetupRegistry.set(this.schemaName, { promise: setupPromise, complete: false });
+      registryEntry = schemaSetupRegistry.get(this.schemaName);
+    }
+    await registryEntry.promise;
+  }
+  /**
+   * Override getSqlType to map JSONB to TEXT for Aurora DSQL compatibility.
+   * Aurora DSQL does not fully support native JSONB, so we store JSON as TEXT
+   * and cast to ::jsonb only when filtering/querying.
+   */
+  getSqlType(type) {
+    switch (type) {
+      case "jsonb":
+        return "TEXT";
+      case "uuid":
+        return "UUID";
+      case "boolean":
+        return "BOOLEAN";
+      default:
+        return storage.getSqlType(type);
+    }
+  }
+  getDefaultValue(type) {
+    switch (type) {
+      case "timestamp":
+        return "DEFAULT NOW()";
+      case "jsonb":
+        return "DEFAULT '{}'";
+      default:
+        return storage.getDefaultValue(type);
+    }
+  }
+  async insert({ tableName, record }) {
+    this.addTimestampZColumns(record);
+    const schemaName = getSchemaName(this.schemaName);
+    const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
+    const values = this.prepareValuesForInsert(record, tableName);
+    const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+    await withRetry(
+      async () => {
+        await this.client.none(
+          `INSERT INTO ${getTableName({ indexName: tableName, schemaName })} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+          values
+        );
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`insert retry ${attempt} for table ${tableName} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  async clearTable({ tableName }) {
+    try {
+      await withRetry(
+        async () => {
+          const schemaName = getSchemaName(this.schemaName);
+          const tableNameWithSchema = getTableName({ indexName: tableName, schemaName });
+          await this.client.none(`DELETE FROM ${tableNameWithSchema}`);
+        },
+        {
+          onRetry: (error, attempt, delay) => {
+            this.logger?.warn?.(`clearTable retry ${attempt} for ${tableName} after ${delay}ms: ${error.message}`);
+          }
+        }
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "CLEAR_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    await withRetry(
+      async () => {
+        const timeZColumnNames = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => name);
+        const timeZColumns = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => {
+          const parsedName = utils.parseSqlIdentifier(name, "column name");
+          return `"${parsedName}Z" TIMESTAMPTZ DEFAULT NOW()`;
+        });
+        const columns = Object.entries(schema).map(([name, def]) => {
+          const parsedName = utils.parseSqlIdentifier(name, "column name");
+          const constraints = [];
+          if (def.primaryKey) constraints.push("PRIMARY KEY");
+          if (!def.nullable) constraints.push("NOT NULL");
+          const sqlType = this.getSqlType(def.type);
+          return `"${parsedName}" ${sqlType} ${constraints.join(" ")}`;
+        });
+        if (this.schemaName) {
+          await this.setupSchema();
+        }
+        const finalColumns = [...columns, ...timeZColumns].join(",\n");
+        const constraintPrefix = this.schemaName ? `${this.schemaName}_` : "";
+        const schemaName = getSchemaName(this.schemaName);
+        const createTableSql = `
+          CREATE TABLE IF NOT EXISTS ${getTableName({ indexName: tableName, schemaName })} (
+            ${finalColumns}
+          );
+        `;
+        await this.client.none(createTableSql);
+        if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+          const indexName = `${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key`;
+          const fullTableName = getTableName({ indexName: tableName, schemaName });
+          try {
+            const indexExists = await this.client.oneOrNone(`SELECT 1 FROM pg_indexes WHERE indexname = $1`, [
+              indexName
+            ]);
+            if (!indexExists) {
+              const result = await this.client.oneOrNone(
+                `CREATE UNIQUE INDEX ASYNC "${indexName}" ON ${fullTableName} ("workflow_name", "run_id")`
+              );
+              if (result?.job_uuid) {
+                await this.waitForDSQLJob(result.job_uuid);
+              }
+              this.logger?.debug?.(`Created unique index ${indexName} on ${fullTableName}`);
+            }
+          } catch (error) {
+            this.logger?.warn?.(`Failed to create unique index ${indexName}:`, error);
+          }
+        }
+        await this.alterTable({
+          tableName,
+          schema,
+          ifNotExists: timeZColumnNames
+        });
+        if (tableName === storage.TABLE_SPANS) {
+          await this.setupTimestampTriggers(tableName);
+          await this.migrateSpansTable();
+        }
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`createTable retry ${attempt} for ${tableName} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "CREATE_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  /**
+   * Set up timestamp triggers for a table to automatically manage createdAt/updatedAt
+   * Note: Aurora DSQL doesn't support triggers, PL/pgSQL, or CREATE FUNCTION.
+   * Timestamps are managed at the application level in insert/update operations.
+   * This method is kept as a no-op for API compatibility.
+   */
+  async setupTimestampTriggers(_tableName) {
+    return;
+  }
+  /**
+   * Migrates the spans table schema from OLD_SPAN_SCHEMA to current SPAN_SCHEMA.
+   * This adds new columns that don't exist in old schema.
+   */
+  async migrateSpansTable() {
+    const fullTableName = getTableName({ indexName: storage.TABLE_SPANS, schemaName: getSchemaName(this.schemaName) });
+    const schema = storage.TABLE_SCHEMAS[storage.TABLE_SPANS];
+    try {
+      for (const [columnName, columnDef] of Object.entries(schema)) {
+        const columnExists = await this.hasColumn(storage.TABLE_SPANS, columnName);
+        if (!columnExists) {
+          const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable ? "" : "NOT NULL";
+          const defaultValue = !columnDef.nullable ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.none(alterSql);
+          this.logger?.debug?.(`Added column '${columnName}' to ${fullTableName}`);
+          if (sqlType === "TIMESTAMP") {
+            const timestampZSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}Z" TIMESTAMPTZ DEFAULT NOW()`.trim();
+            await this.client.none(timestampZSql);
+            this.logger?.debug?.(`Added timezone column '${columnName}Z' to ${fullTableName}`);
+          }
+        }
+      }
+      for (const [columnName, columnDef] of Object.entries(schema)) {
+        if (columnDef.type === "timestamp") {
+          const tzColumnName = `${columnName}Z`;
+          const tzColumnExists = await this.hasColumn(storage.TABLE_SPANS, tzColumnName);
+          if (!tzColumnExists) {
+            const parsedTzColumnName = utils.parseSqlIdentifier(tzColumnName, "column name");
+            const timestampZSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedTzColumnName}" TIMESTAMPTZ DEFAULT NOW()`.trim();
+            await this.client.none(timestampZSql);
+            this.logger?.debug?.(`Added timezone column '${tzColumnName}' to ${fullTableName}`);
+          }
+        }
+      }
+      this.logger?.info?.(`Migration completed for ${fullTableName}`);
+    } catch (error) {
+      this.logger?.warn?.(`Failed to migrate spans table ${fullTableName}:`, error);
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+    try {
+      for (const columnName of ifNotExists) {
+        if (schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
+          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType}`;
+          await this.client.none(alterSql);
+          if (sqlType === "TIMESTAMP") {
+            const alterSqlZ = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}Z" TIMESTAMPTZ`;
+            await this.client.none(alterSqlZ);
+          }
+          this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "ALTER_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      const keyEntries = Object.entries(keys).map(([key, value]) => [utils.parseSqlIdentifier(key, "column name"), value]);
+      const conditions = keyEntries.map(([key], index) => `"${key}" = $${index + 1}`).join(" AND ");
+      const values = keyEntries.map(([_, value]) => value);
+      const result = await this.client.oneOrNone(
+        `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions} ORDER BY "createdAt" DESC LIMIT 1`,
+        values
+      );
+      if (!result) {
+        return null;
+      }
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        const snapshot = result;
+        if (typeof snapshot.snapshot === "string") {
+          snapshot.snapshot = JSON.parse(snapshot.snapshot);
+        }
+        return snapshot;
+      }
+      return result;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LOAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    if (records.length === 0) {
+      return;
+    }
+    try {
+      const { batches } = splitIntoBatches(records, { maxRows: DEFAULT_MAX_ROWS_PER_BATCH });
+      for (const batch of batches) {
+        await withRetry(
+          async () => {
+            await this.client.tx(async (t) => {
+              for (const record of batch) {
+                this.addTimestampZColumns(record);
+                const schemaName = getSchemaName(this.schemaName);
+                const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
+                const values = this.prepareValuesForInsert(record, tableName);
+                const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+                await t.none(
+                  `INSERT INTO ${getTableName({ indexName: tableName, schemaName })} (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+                  values
+                );
+              }
+            });
+          },
+          {
+            onRetry: (error, attempt, delay) => {
+              this.logger?.warn?.(
+                `Batch insert retry ${attempt} for table ${tableName} after ${delay}ms: ${error.message}`
+              );
+            }
+          }
+        );
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "BATCH_INSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: records.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async dropTable({ tableName }) {
+    try {
+      const schemaName = getSchemaName(this.schemaName);
+      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName });
+      await this.client.none(`DROP TABLE IF EXISTS ${tableNameWithSchema}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DROP_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Wait for an asynchronous DSQL job to complete.
+   * Aurora DSQL requires CREATE INDEX ASYNC and sys.wait_for_job() to wait for completion.
+   */
+  async waitForDSQLJob(jobUuid, timeoutMs = 6e4) {
+    const pollIntervalMs = 1e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const result = await this.client.oneOrNone(`SELECT sys.wait_for_job($1, 1) as status`, [
+        jobUuid
+      ]);
+      if (result?.status === "COMPLETED") {
+        return;
+      }
+      if (result?.status === "FAILED") {
+        throw new Error(`DSQL async job ${jobUuid} failed`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(`DSQL async job ${jobUuid} timed out after ${timeoutMs}ms`);
+  }
+  async createIndex(options) {
+    try {
+      const {
+        name,
+        table,
+        columns,
+        unique = false,
+        // Note: 'concurrent' option is ignored in DSQL - always uses ASYNC
+        where,
+        method = "btree",
+        opclass,
+        storage,
+        tablespace
+      } = options;
+      const schemaName = this.schemaName || "public";
+      const fullTableName = getTableName({
+        indexName: table,
+        schemaName: getSchemaName(this.schemaName)
+      });
+      const indexExists = await this.client.oneOrNone(
+        `SELECT 1 as exists FROM pg_indexes
+         WHERE indexname = $1
+         AND schemaname = $2`,
+        [name, schemaName]
+      );
+      if (indexExists) {
+        return;
+      }
+      const uniqueStr = unique ? "UNIQUE " : "";
+      const methodStr = method !== "btree" ? `USING ${method} ` : "";
+      const columnsStr = columns.map((col) => {
+        const colName = col.replace(/\s+(DESC|ASC)$/i, "").trim();
+        const quotedCol = `"${utils.parseSqlIdentifier(colName, "column name")}"`;
+        return opclass ? `${quotedCol} ${opclass}` : quotedCol;
+      }).join(", ");
+      const whereStr = where ? ` WHERE ${where}` : "";
+      const tablespaceStr = tablespace ? ` TABLESPACE ${tablespace}` : "";
+      let withStr = "";
+      if (storage && Object.keys(storage).length > 0) {
+        const storageParams = Object.entries(storage).map(([key, value]) => `${key} = ${value}`).join(", ");
+        withStr = ` WITH (${storageParams})`;
+      }
+      const quotedIndexName = `"${utils.parseSqlIdentifier(name, "index name")}"`;
+      const sql = `CREATE ${uniqueStr}INDEX ASYNC ${quotedIndexName} ON ${fullTableName} ${methodStr}(${columnsStr})${withStr}${tablespaceStr}${whereStr}`;
+      const result = await this.client.oneOrNone(sql);
+      if (result?.job_uuid) {
+        await this.waitForDSQLJob(result.job_uuid);
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INDEX_CREATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName: options.name,
+            tableName: options.table
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async dropIndex(indexName) {
+    const schemaName = this.schemaName || "public";
+    await withRetry(
+      async () => {
+        const indexExists = await this.client.oneOrNone(
+          `SELECT 1 FROM pg_indexes
+           WHERE indexname = $1
+           AND schemaname = $2`,
+          [indexName, schemaName]
+        );
+        if (!indexExists) {
+          return;
+        }
+        const quotedIndexName = `"${utils.parseSqlIdentifier(indexName, "index name")}"`;
+        const sql = `DROP INDEX IF EXISTS ${getSchemaName(this.schemaName)}.${quotedIndexName}`;
+        await this.client.none(sql);
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`dropIndex retry ${attempt} for ${indexName} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INDEX_DROP", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  async listIndexes(tableName) {
+    try {
+      const schemaName = this.schemaName || "public";
+      let query;
+      let params;
+      if (tableName) {
+        query = `
+          SELECT
+            i.indexname as name,
+            i.tablename as table,
+            i.indexdef as definition,
+            ix.indisunique as is_unique,
+            pg_size_pretty(pg_relation_size(c.oid)) as size,
+            array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns
+          FROM pg_indexes i
+          JOIN pg_class c ON c.relname = i.indexname AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = i.schemaname)
+          JOIN pg_index ix ON ix.indexrelid = c.oid
+          JOIN pg_attribute a ON a.attrelid = ix.indrelid AND a.attnum = ANY(ix.indkey)
+          WHERE i.schemaname = $1
+          AND i.tablename = $2
+          GROUP BY i.indexname, i.tablename, i.indexdef, ix.indisunique, c.oid
+        `;
+        params = [schemaName, tableName];
+      } else {
+        query = `
+          SELECT
+            i.indexname as name,
+            i.tablename as table,
+            i.indexdef as definition,
+            ix.indisunique as is_unique,
+            pg_size_pretty(pg_relation_size(c.oid)) as size,
+            array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns
+          FROM pg_indexes i
+          JOIN pg_class c ON c.relname = i.indexname AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = i.schemaname)
+          JOIN pg_index ix ON ix.indexrelid = c.oid
+          JOIN pg_attribute a ON a.attrelid = ix.indrelid AND a.attnum = ANY(ix.indkey)
+          WHERE i.schemaname = $1
+          GROUP BY i.indexname, i.tablename, i.indexdef, ix.indisunique, c.oid
+        `;
+        params = [schemaName];
+      }
+      const results = await this.client.manyOrNone(query, params);
+      return results.map((row) => {
+        let columns = [];
+        if (typeof row.columns === "string" && row.columns.startsWith("{") && row.columns.endsWith("}")) {
+          const arrayContent = row.columns.slice(1, -1);
+          columns = arrayContent ? arrayContent.split(",") : [];
+        } else if (Array.isArray(row.columns)) {
+          columns = row.columns;
+        }
+        return {
+          name: row.name,
+          table: row.table,
+          columns,
+          unique: row.is_unique || false,
+          size: row.size || "0",
+          definition: row.definition || ""
+        };
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INDEX_LIST", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: tableName ? {
+            tableName
+          } : {}
+        },
+        error$1
+      );
+    }
+  }
+  async describeIndex(indexName) {
+    try {
+      const schemaName = this.schemaName || "public";
+      const query = `
+        SELECT
+          i.indexname as name,
+          i.tablename as table,
+          i.indexdef as definition,
+          ix.indisunique as is_unique,
+          pg_size_pretty(pg_relation_size(c.oid)) as size,
+          array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns,
+          am.amname as method,
+          s.idx_scan as scans,
+          s.idx_tup_read as tuples_read,
+          s.idx_tup_fetch as tuples_fetched
+        FROM pg_indexes i
+        JOIN pg_class c ON c.relname = i.indexname AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = i.schemaname)
+        JOIN pg_index ix ON ix.indexrelid = c.oid
+        JOIN pg_attribute a ON a.attrelid = ix.indrelid AND a.attnum = ANY(ix.indkey)
+        JOIN pg_am am ON c.relam = am.oid
+        LEFT JOIN pg_stat_user_indexes s ON s.indexrelname = i.indexname AND s.schemaname = i.schemaname
+        WHERE i.schemaname = $1
+        AND i.indexname = $2
+        GROUP BY i.indexname, i.tablename, i.indexdef, ix.indisunique, c.oid, am.amname, s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
+      `;
+      const result = await this.client.oneOrNone(query, [schemaName, indexName]);
+      if (!result) {
+        throw new Error(`Index "${indexName}" not found in schema "${schemaName}"`);
+      }
+      let columns = [];
+      if (typeof result.columns === "string" && result.columns.startsWith("{") && result.columns.endsWith("}")) {
+        const arrayContent = result.columns.slice(1, -1);
+        columns = arrayContent ? arrayContent.split(",") : [];
+      } else if (Array.isArray(result.columns)) {
+        columns = result.columns;
+      }
+      const normalizedMethod = result.method === "btree_index" ? "btree" : result.method || "btree";
+      return {
+        name: result.name,
+        table: result.table,
+        columns,
+        unique: result.is_unique || false,
+        size: result.size || "0",
+        definition: result.definition || "",
+        method: normalizedMethod,
+        scans: parseInt(result.scans) || 0,
+        tuples_read: parseInt(result.tuples_read) || 0,
+        tuples_fetched: parseInt(result.tuples_fetched) || 0
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INDEX_DESCRIBE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async update({
+    tableName,
+    keys,
+    data
+  }) {
+    const setColumns = [];
+    const setValues = [];
+    let paramIndex = 1;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const dataWithTimestamp = {
+      ...data,
+      updatedAt: now,
+      updatedAtZ: now
+    };
+    Object.entries(dataWithTimestamp).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      setColumns.push(`"${parsedKey}" = $${paramIndex++}`);
+      setValues.push(this.prepareValue(value, key, tableName));
+    });
+    const whereConditions = [];
+    const whereValues = [];
+    Object.entries(keys).forEach(([key, value]) => {
+      const parsedKey = utils.parseSqlIdentifier(key, "column name");
+      whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
+      whereValues.push(this.prepareValue(value, key, tableName));
+    });
+    const tableName_ = getTableName({
+      indexName: tableName,
+      schemaName: getSchemaName(this.schemaName)
+    });
+    const sql = `UPDATE ${tableName_} SET ${setColumns.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
+    const values = [...setValues, ...whereValues];
+    await withRetry(
+      async () => {
+        await this.client.none(sql, values);
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`update retry ${attempt} for table ${tableName} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  async batchUpdate({
+    tableName,
+    updates
+  }) {
+    if (updates.length === 0) {
+      return;
+    }
+    try {
+      const { batches } = splitIntoBatches(updates, { maxRows: DEFAULT_MAX_ROWS_PER_BATCH });
+      for (const batch of batches) {
+        await withRetry(
+          async () => {
+            await this.client.tx(async (t) => {
+              for (const { keys, data } of batch) {
+                const setClauses = [];
+                const whereConditions = [];
+                const values = [];
+                let paramIndex = 1;
+                const now = (/* @__PURE__ */ new Date()).toISOString();
+                const dataWithTimestamp = {
+                  ...data,
+                  updatedAt: now,
+                  updatedAtZ: now
+                };
+                Object.entries(dataWithTimestamp).forEach(([key, value]) => {
+                  const parsedKey = utils.parseSqlIdentifier(key, "column name");
+                  const preparedValue = this.prepareValue(value, key, tableName);
+                  setClauses.push(`"${parsedKey}" = $${paramIndex++}`);
+                  values.push(preparedValue);
+                });
+                Object.entries(keys).forEach(([key, value]) => {
+                  const parsedKey = utils.parseSqlIdentifier(key, "column name");
+                  whereConditions.push(`"${parsedKey}" = $${paramIndex++}`);
+                  values.push(value);
+                });
+                const tableName_ = getTableName({
+                  indexName: tableName,
+                  schemaName: getSchemaName(this.schemaName)
+                });
+                const sql = `UPDATE ${tableName_} SET ${setClauses.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
+                await t.none(sql, values);
+              }
+            });
+          },
+          {
+            onRetry: (error, attempt, delay) => {
+              this.logger?.warn?.(
+                `Batch update retry ${attempt} for table ${tableName} after ${delay}ms: ${error.message}`
+              );
+            }
+          }
+        );
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "BATCH_UPDATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: updates.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchDelete({ tableName, keys }) {
+    if (keys.length === 0) {
+      return;
+    }
+    try {
+      const tableName_ = getTableName({
+        indexName: tableName,
+        schemaName: getSchemaName(this.schemaName)
+      });
+      const { batches } = splitIntoBatches(keys, { maxRows: DEFAULT_MAX_ROWS_PER_BATCH });
+      for (const batch of batches) {
+        await withRetry(
+          async () => {
+            await this.client.tx(async (t) => {
+              for (const keySet of batch) {
+                const conditions = [];
+                const values = [];
+                let paramIndex = 1;
+                Object.entries(keySet).forEach(([key, value]) => {
+                  const parsedKey = utils.parseSqlIdentifier(key, "column name");
+                  conditions.push(`"${parsedKey}" = $${paramIndex++}`);
+                  values.push(value);
+                });
+                const sql = `DELETE FROM ${tableName_} WHERE ${conditions.join(" AND ")}`;
+                await t.none(sql, values);
+              }
+            });
+          },
+          {
+            onRetry: (error, attempt, delay) => {
+              this.logger?.warn?.(
+                `Batch delete retry ${attempt} for table ${tableName} after ${delay}ms: ${error.message}`
+              );
+            }
+          }
+        );
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "BATCH_DELETE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: keys.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Delete all data from a table (alias for clearTable for consistency with other stores)
+   */
+  async deleteData({ tableName }) {
+    return this.clearTable({ tableName });
+  }
+};
+function getSchemaName2(schema) {
+  return schema ? `"${utils.parseSqlIdentifier(schema, "schema name")}"` : void 0;
+}
+function getTableName2({ indexName, schemaName }) {
+  const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+  const quotedIndexName = `"${parsedIndexName}"`;
+  const quotedSchemaName = schemaName;
+  return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
+}
+function transformFromSqlRow({
+  tableName,
+  sqlRow
+}) {
+  const schema = storage.TABLE_SCHEMAS[tableName];
+  const result = {};
+  Object.entries(sqlRow).forEach(([key, value]) => {
+    const columnSchema = schema?.[key];
+    if (columnSchema?.type === "jsonb" && typeof value === "string") {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else if (columnSchema?.type === "timestamp" && value && typeof value === "string") {
+      result[key] = new Date(value);
+    } else if (columnSchema?.type === "timestamp" && value instanceof Date) {
+      result[key] = value;
+    } else if (columnSchema?.type === "boolean") {
+      result[key] = Boolean(value);
+    } else {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+
+// src/storage/domains/agents/index.ts
+var AgentsDSQL = class _AgentsDSQL extends storage.AgentsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_AGENTS, storage.TABLE_AGENT_VERSIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolveDsqlConfig(config);
+    this.#db = new DsqlDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _AgentsDSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  /**
+   * Returns default index definitions for the agents domain tables.
+   * Currently no default indexes are defined for agents.
+   */
+  getDefaultIndexDefinitions() {
+    return [];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   * Currently no default indexes are defined for agents.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_AGENTS, schema: storage.TABLE_SCHEMAS[storage.TABLE_AGENTS] });
+    await this.#db.createTable({ tableName: storage.TABLE_AGENT_VERSIONS, schema: storage.TABLE_SCHEMAS[storage.TABLE_AGENT_VERSIONS] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_AGENT_VERSIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_AGENTS });
+  }
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error$1) {
+      const details = {
+        value: value.length > 100 ? value.substring(0, 100) + "..." : value
+      };
+      if (fieldName) {
+        details.field = fieldName;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "PARSE_JSON", "INVALID_JSON"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error$1 instanceof Error ? error$1.message : "Unknown error"}`,
+          details
+        },
+        error$1
+      );
+    }
+  }
+  parseRow(row) {
+    return {
+      id: row.id,
+      status: row.status,
+      activeVersionId: row.activeVersionId,
+      authorId: row.authorId,
+      metadata: this.parseJson(row.metadata, "metadata"),
+      createdAt: row.createdAtZ || row.createdAt,
+      updatedAt: row.updatedAtZ || row.updatedAt
+    };
+  }
+  async getById(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_AGENT_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { agent } = input;
+    const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    try {
+      await withRetry(
+        () => this.#db.client.none(
+          `INSERT INTO ${tableName} (
+              id, status, "authorId", metadata,
+              "activeVersionId",
+              "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+          [
+            agent.id,
+            "draft",
+            agent.authorId ?? null,
+            agent.metadata ? JSON.stringify(agent.metadata) : null,
+            null,
+            // activeVersionId starts as null
+            nowIso,
+            nowIso,
+            nowIso,
+            nowIso
+          ]
+        )
+      );
+      const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = agent;
+      const versionId = crypto.randomUUID();
+      await this.createVersion({
+        id: versionId,
+        agentId: agent.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version"
+      });
+      return {
+        id: agent.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: agent.authorId,
+        metadata: agent.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      try {
+        await this.#db.client.none(
+          `DELETE FROM ${tableName} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`,
+          [agent.id]
+        );
+      } catch {
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "CREATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: agent.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      const existingAgent = await this.getById(id);
+      if (!existingAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("DSQL", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Agent ${id} not found`,
+          details: { agentId: id }
+        });
+      }
+      const { authorId, activeVersionId, metadata, status } = updates;
+      const setClauses = [];
+      const values = [];
+      let paramIndex = 1;
+      if (authorId !== void 0) {
+        setClauses.push(`"authorId" = $${paramIndex++}`);
+        values.push(authorId);
+      }
+      if (activeVersionId !== void 0) {
+        setClauses.push(`"activeVersionId" = $${paramIndex++}`);
+        values.push(activeVersionId);
+      }
+      if (status !== void 0) {
+        setClauses.push(`status = $${paramIndex++}`);
+        values.push(status);
+      }
+      if (metadata !== void 0) {
+        setClauses.push(`metadata = $${paramIndex++}`);
+        values.push(JSON.stringify(metadata));
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setClauses.push(`"updatedAt" = $${paramIndex++}`);
+      values.push(now);
+      setClauses.push(`"updatedAtZ" = $${paramIndex++}`);
+      values.push(now);
+      values.push(id);
+      await withRetry(
+        () => this.#db.client.none(`UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE id = ${paramIndex}`, values)
+      );
+      const updatedAgent = await this.getById(id);
+      if (!updatedAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("DSQL", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Agent ${id} not found after update`,
+          details: { agentId: id }
+        });
+      }
+      return updatedAgent;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      await this.deleteVersionsByParentId(id);
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_AGENTS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = [];
+      const queryParams = [];
+      let paramIdx = 1;
+      if (status) {
+        conditions.push(`status = $${paramIdx++}`);
+        queryParams.push(status);
+      }
+      if (authorId !== void 0) {
+        conditions.push(`"authorId" = $${paramIdx++}`);
+        queryParams.push(authorId);
+      }
+      if (metadata && Object.keys(metadata).length > 0) {
+        conditions.push(`metadata::text = $${paramIdx++}`);
+        queryParams.push(JSON.stringify(metadata));
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
+      );
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "${field}" ${direction} LIMIT $${paramIdx++} OFFSET $${paramIdx++}`,
+        [...queryParams, limitValue, offset]
+      );
+      const agents = (dataResult || []).map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_AGENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Agent Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await withRetry(
+        () => this.#db.client.none(
+          `INSERT INTO ${tableName} (
+              id, "agentId", "versionNumber",
+              name, description, instructions, model, tools,
+              "defaultOptions", workflows, agents, "integrationTools",
+              "inputProcessors", "outputProcessors", memory, scorers,
+              "mcpClients", "requestContextSchema", workspace, skills, "skillsFormat",
+              "changedFields", "changeMessage",
+              "createdAt", "createdAtZ"
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25)`,
+          [
+            input.id,
+            input.agentId,
+            input.versionNumber,
+            input.name,
+            input.description ?? null,
+            this.serializeInstructions(input.instructions),
+            JSON.stringify(input.model),
+            input.tools ? JSON.stringify(input.tools) : null,
+            input.defaultOptions ? JSON.stringify(input.defaultOptions) : null,
+            input.workflows ? JSON.stringify(input.workflows) : null,
+            input.agents ? JSON.stringify(input.agents) : null,
+            input.integrationTools ? JSON.stringify(input.integrationTools) : null,
+            input.inputProcessors ? JSON.stringify(input.inputProcessors) : null,
+            input.outputProcessors ? JSON.stringify(input.outputProcessors) : null,
+            input.memory ? JSON.stringify(input.memory) : null,
+            input.scorers ? JSON.stringify(input.scorers) : null,
+            input.mcpClients ? JSON.stringify(input.mcpClients) : null,
+            input.requestContextSchema ? JSON.stringify(input.requestContextSchema) : null,
+            input.workspace ? JSON.stringify(input.workspace) : null,
+            input.skills ? JSON.stringify(input.skills) : null,
+            input.skillsFormat ?? null,
+            input.changedFields ? JSON.stringify(input.changedFields) : null,
+            input.changeMessage ?? null,
+            nowIso,
+            nowIso
+          ]
+        )
+      );
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "CREATE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, agentId: input.agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 AND "versionNumber" = $2`,
+        [agentId, versionNumber]
+      );
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 ORDER BY "versionNumber" DESC LIMIT 1`,
+        [agentId]
+      );
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_LATEST_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const sortField = orderBy?.field || "versionNumber";
+    const sortDirection = orderBy?.direction || "DESC";
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "agentId" = $1`, [
+        agentId
+      ]);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          versions: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 ORDER BY "${sortField}" ${sortDirection} LIMIT $2 OFFSET $3`,
+        [agentId, limitValue, offset]
+      );
+      const versions = (rows || []).map((row) => this.parseVersionRow(row));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByParentId(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "agentId" = $1`, [agentId]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_VERSIONS_BY_PARENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "agentId" = $1`, [
+        agentId
+      ]);
+      return parseInt(result.count, 10);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "COUNT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  serializeInstructions(instructions) {
+    if (instructions == null) return void 0;
+    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
+  }
+  deserializeInstructions(raw) {
+    if (!raw) return "";
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    return raw;
+  }
+  parseVersionRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agentId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      description: row.description,
+      instructions: this.deserializeInstructions(row.instructions),
+      model: this.parseJson(row.model, "model"),
+      tools: this.parseJson(row.tools, "tools"),
+      defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
+      workflows: this.parseJson(row.workflows, "workflows"),
+      agents: this.parseJson(row.agents, "agents"),
+      integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
+      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
+      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
+      memory: this.parseJson(row.memory, "memory"),
+      scorers: this.parseJson(row.scorers, "scorers"),
+      mcpClients: this.parseJson(row.mcpClients, "mcpClients"),
+      requestContextSchema: this.parseJson(row.requestContextSchema, "requestContextSchema"),
+      workspace: this.parseJson(row.workspace, "workspace"),
+      skills: this.parseJson(row.skills, "skills"),
+      skillsFormat: row.skillsFormat,
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage,
+      createdAt: row.createdAtZ || row.createdAt
+    };
+  }
+};
+function inPlaceholders(count, startIndex = 1) {
+  return Array.from({ length: count }, (_, i) => `$${i + startIndex}`).join(", ");
+}
+var MemoryDSQL = class _MemoryDSQL extends storage.MemoryStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_RESOURCES];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolveDsqlConfig(config);
+    this.#db = new DsqlDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _MemoryDSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_THREADS, schema: storage.TABLE_SCHEMAS[storage.TABLE_THREADS] });
+    await this.#db.createTable({ tableName: storage.TABLE_MESSAGES, schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: storage.TABLE_RESOURCES, schema: storage.TABLE_SCHEMAS[storage.TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_MESSAGES,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the memory domain tables.
+   * Note: Aurora DSQL does not support ASC/DESC in index columns.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_threads_resourceid_createdat_idx`,
+        table: storage.TABLE_THREADS,
+        columns: ["resourceId", "createdAt"]
+      },
+      {
+        name: `${schemaPrefix}mastra_messages_thread_id_createdat_idx`,
+        table: storage.TABLE_MESSAGES,
+        columns: ["thread_id", "createdAt"]
+      }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: storage.TABLE_THREADS });
+    await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
+  }
+  /**
+   * Normalizes message row from database by applying createdAtZ fallback
+   */
+  normalizeMessageRow(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      role: row.role,
+      type: row.type,
+      createdAt: row.createdAtZ || row.createdAt,
+      threadId: row.threadId,
+      resourceId: row.resourceId
+    };
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+      const thread = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE id = $1`,
+        [threadId]
+      );
+      if (!thread) {
+        return null;
+      }
+      return {
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_THREAD_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error$1) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("DSQL", "LIST_THREADS", "INVALID_PAGE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: error$1 instanceof Error ? error$1.message : "Invalid pagination parameters",
+        details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+      });
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error$1) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("DSQL", "LIST_THREADS", "INVALID_METADATA_KEY"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: error$1 instanceof Error ? error$1.message : "Invalid metadata key",
+        details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+      });
+    }
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+      const whereClauses = [];
+      const queryParams = [];
+      let paramIndex = 1;
+      if (filter?.resourceId) {
+        whereClauses.push(`"resourceId" = ${paramIndex}`);
+        queryParams.push(filter.resourceId);
+        paramIndex++;
+      }
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        for (const [key, value] of Object.entries(filter.metadata)) {
+          whereClauses.push(`metadata::jsonb @> ${paramIndex}::jsonb`);
+          queryParams.push(JSON.stringify({ [key]: value }));
+          paramIndex++;
+        }
+      }
+      const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+      const baseQuery = `FROM ${tableName} ${whereClause}`;
+      const countQuery = `SELECT COUNT(*) ${baseQuery}`;
+      const countResult = await this.#db.client.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT ${paramIndex} OFFSET ${paramIndex + 1}`;
+      const rows = await this.#db.client.manyOrNone(
+        dataQuery,
+        [...queryParams, limitValue, offset]
+      );
+      const threads = (rows || []).map((thread) => ({
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt
+      }));
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_THREADS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata,
+            page
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveThread({ thread }) {
+    const tableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+    await withRetry(
+      async () => {
+        await this.#db.client.none(
+          `INSERT INTO ${tableName} (
+            id,
+            "resourceId",
+            title,
+            metadata,
+            "createdAt",
+            "createdAtZ",
+            "updatedAt",
+            "updatedAtZ"
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+          ON CONFLICT (id) DO UPDATE SET
+            "resourceId" = EXCLUDED."resourceId",
+            title = EXCLUDED.title,
+            metadata = EXCLUDED.metadata,
+            "createdAt" = EXCLUDED."createdAt",
+            "createdAtZ" = EXCLUDED."createdAtZ",
+            "updatedAt" = EXCLUDED."updatedAt",
+            "updatedAtZ" = EXCLUDED."updatedAtZ"`,
+          [
+            thread.id,
+            thread.resourceId,
+            thread.title,
+            thread.metadata ? JSON.stringify(thread.metadata) : null,
+            thread.createdAt,
+            thread.createdAt,
+            thread.updatedAt,
+            thread.updatedAt
+          ]
+        );
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`saveThread retry ${attempt} for ${thread.id} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "SAVE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: thread.id
+          }
+        },
+        error$1
+      );
+    });
+    return thread;
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const threadTableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+    const { result } = await withRetry(
+      async () => {
+        const existingThread = await this.getThreadById({ threadId: id });
+        if (!existingThread) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("DSQL", "UPDATE_THREAD", "NOT_FOUND"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER,
+            text: `Thread ${id} not found`,
+            details: {
+              threadId: id,
+              title
+            }
+          });
+        }
+        const mergedMetadata = {
+          ...existingThread.metadata,
+          ...metadata
+        };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const thread = await this.#db.client.one(
+          `UPDATE ${threadTableName}
+                      SET 
+                          title = $1,
+                          metadata = $2,
+                          "updatedAt" = $3::timestamp,
+                          "updatedAtZ" = $4::timestamptz
+                      WHERE id = $5
+                      RETURNING *
+                  `,
+          [title, JSON.stringify(mergedMetadata), now, now, id]
+        );
+        return {
+          id: thread.id,
+          resourceId: thread.resourceId,
+          title: thread.title,
+          metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+          createdAt: thread.createdAtZ || thread.createdAt,
+          updatedAt: thread.updatedAtZ || thread.updatedAt
+        };
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`updateThread retry ${attempt} for ${id} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+            title
+          }
+        },
+        error$1
+      );
+    });
+    return result;
+  }
+  async deleteThread({ threadId }) {
+    const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+    const threadTableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+    await withRetry(
+      async () => {
+        await this.#db.client.tx(async (t) => {
+          await t.none(`DELETE FROM ${tableName} WHERE thread_id = $1`, [threadId]);
+          await t.none(`DELETE FROM ${threadTableName} WHERE id = $1`, [threadId]);
+        });
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`deleteThread retry ${attempt} for ${threadId} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    });
+  }
+  async _getIncludedMessages({ include }) {
+    if (!include || include.length === 0) return null;
+    const unionQueries = [];
+    const params = [];
+    let paramIdx = 1;
+    const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      unionQueries.push(
+        `
+            SELECT * FROM (
+              WITH target_thread AS (
+                SELECT thread_id FROM ${tableName} WHERE id = $${paramIdx}
+              ),
+              ordered_messages AS (
+                SELECT
+                  *,
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                FROM ${tableName}
+                WHERE thread_id = (SELECT thread_id FROM target_thread)
+              )
+              SELECT
+                m.id,
+                m.content,
+                m.role,
+                m.type,
+                m."createdAt",
+                m."createdAtZ",
+                m.thread_id AS "threadId",
+                m."resourceId"
+              FROM ordered_messages m
+              WHERE m.id = $${paramIdx}
+              OR EXISTS (
+                SELECT 1 FROM ordered_messages target
+                WHERE target.id = $${paramIdx}
+                AND (
+                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 1})
+                  OR
+                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 2})
+                )
+              )
+            ) AS query_${paramIdx}
+            `
+      );
+      params.push(id, withPreviousMessages, withNextMessages);
+      paramIdx += 3;
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedRows = await this.#db.client.manyOrNone(finalQuery, params);
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedRows = includedRows.filter((row) => {
+      if (seen.has(row.id)) return false;
+      seen.add(row.id);
+      return true;
+    });
+    return dedupedRows;
+  }
+  parseRow(row) {
+    const normalized = this.normalizeMessageRow(row);
+    let content = normalized.content;
+    try {
+      content = JSON.parse(normalized.content);
+    } catch {
+    }
+    return {
+      id: normalized.id,
+      content,
+      role: normalized.role,
+      createdAt: new Date(normalized.createdAt),
+      threadId: normalized.threadId,
+      resourceId: normalized.resourceId,
+      ...normalized.type && normalized.type !== "v2" ? { type: normalized.type } : {}
+    };
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+      const query = `
+        ${selectStatement} FROM ${tableName}
+        WHERE id IN (${inPlaceholders(messageIds.length)})
+        ORDER BY "createdAt" DESC
+      `;
+      const resultRows = await this.#db.client.manyOrNone(query, messageIds);
+      const list = new agent.MessageList().add(
+        resultRows.map((row) => this.parseRow(row)),
+        "memory"
+      );
+      return { messages: list.get.all.db() };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_MESSAGES_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return { messages: [] };
+    }
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = (Array.isArray(threadId) ? threadId : [threadId]).filter(
+      (id) => typeof id === "string"
+    );
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { threadId: Array.isArray(threadId) ? String(threadId) : String(threadId) }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    if (page < 0) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("DSQL", "LIST_MESSAGES", "INVALID_PAGE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+          page
+        }
+      });
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY "${field}" ${direction}`;
+      const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
+      const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+      const conditions = [`thread_id IN (${inPlaceholders(threadIds.length)})`];
+      const queryParams = [...threadIds];
+      let paramIndex = threadIds.length + 1;
+      if (resourceId) {
+        conditions.push(`"resourceId" = $${paramIndex++}`);
+        queryParams.push(resourceId);
+      }
+      if (filter?.dateRange?.start) {
+        conditions.push(`"createdAtZ" >= $${paramIndex++}::timestamptz`);
+        queryParams.push(filter.dateRange.start);
+      }
+      if (filter?.dateRange?.end) {
+        conditions.push(`"createdAtZ" <= $${paramIndex++}::timestamptz`);
+        queryParams.push(filter.dateRange.end);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countQuery = `SELECT COUNT(*) FROM ${tableName} ${whereClause}`;
+      const countResult = await this.#db.client.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.#db.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
+      const messages = [...rows || []];
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const messagesWithParsedContent = messages.map((row) => this.parseRow(row));
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
+        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
+        if (aValue == null && bValue == null) return a.id.localeCompare(b.id);
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)
+      );
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages: [] };
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("DSQL", "SAVE_MESSAGES", "FAILED"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ID is required`
+      });
+    }
+    const thread = await this.getThreadById({ threadId });
+    if (!thread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("DSQL", "SAVE_MESSAGES", "FAILED"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${threadId} not found`,
+        details: {
+          threadId
+        }
+      });
+    }
+    const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+    const threadTableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+    await withRetry(
+      async () => {
+        await this.#db.client.tx(async (t) => {
+          const messageInserts = messages.map((message) => {
+            if (!message.threadId) {
+              throw new Error(
+                `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+              );
+            }
+            if (!message.resourceId) {
+              throw new Error(
+                `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+              );
+            }
+            const createdAtIso = message.createdAt ? new Date(message.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+            return t.none(
+              `INSERT INTO ${tableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId") 
+               VALUES ($1, $2, $3, $4::timestamp, $5::timestamptz, $6, $7, $8)
+               ON CONFLICT (id) DO UPDATE SET
+                thread_id = EXCLUDED.thread_id,
+                content = EXCLUDED.content,
+                role = EXCLUDED.role,
+                type = EXCLUDED.type,
+                "resourceId" = EXCLUDED."resourceId"`,
+              [
+                message.id,
+                message.threadId,
+                typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+                createdAtIso,
+                createdAtIso,
+                message.role,
+                message.type || "v2",
+                message.resourceId
+              ]
+            );
+          });
+          const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+          const threadUpdate = t.none(
+            `UPDATE ${threadTableName} 
+                          SET 
+                              "updatedAt" = $1::timestamp,
+                              "updatedAtZ" = $2::timestamptz
+                          WHERE id = $3
+                      `,
+            [nowIso, nowIso, threadId]
+          );
+          await Promise.all([...messageInserts, threadUpdate]);
+        });
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(
+            `saveMessages retry ${attempt} for thread ${threadId} after ${delay}ms: ${error.message}`
+          );
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "SAVE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId
+          }
+        },
+        error$1
+      );
+    });
+    const messagesWithParsedContent = messages.map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          return { ...message, content: JSON.parse(message.content) };
+        } catch {
+          return message;
+        }
+      }
+      return message;
+    });
+    const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
+    return { messages: list.get.all.db() };
+  }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) })} WHERE id IN (${inPlaceholders(messageIds.length)})`;
+    const existingMessagesDb = await this.#db.client.manyOrNone(selectQuery, messageIds);
+    if (existingMessagesDb.length === 0) {
+      return [];
+    }
+    const existingMessages = existingMessagesDb.map((msg) => {
+      if (typeof msg.content === "string") {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
+        }
+      }
+      return msg;
+    });
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    await withRetry(
+      async () => {
+        await this.#db.client.tx(async (t) => {
+          const queries = [];
+          const columnMapping = {
+            threadId: "thread_id"
+          };
+          for (const existingMessage of existingMessages) {
+            const updatePayload = messages.find((m) => m.id === existingMessage.id);
+            if (!updatePayload) continue;
+            const { id, ...fieldsToUpdate } = updatePayload;
+            if (Object.keys(fieldsToUpdate).length === 0) continue;
+            threadIdsToUpdate.add(existingMessage.threadId);
+            if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+              threadIdsToUpdate.add(updatePayload.threadId);
+            }
+            const setClauses = [];
+            const values = [];
+            let paramIndex = 1;
+            const updatableFields = { ...fieldsToUpdate };
+            if (updatableFields.content) {
+              const newContent = {
+                ...existingMessage.content,
+                ...updatableFields.content,
+                ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+                  metadata: {
+                    ...existingMessage.content.metadata,
+                    ...updatableFields.content.metadata
+                  }
+                } : {}
+              };
+              setClauses.push(`content = $${paramIndex++}`);
+              values.push(newContent);
+              delete updatableFields.content;
+            }
+            for (const key in updatableFields) {
+              if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+                const dbColumn = columnMapping[key] || key;
+                setClauses.push(`"${dbColumn}" = $${paramIndex++}`);
+                values.push(updatableFields[key]);
+              }
+            }
+            if (setClauses.length > 0) {
+              values.push(id);
+              const sql = `UPDATE ${getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) })} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+              queries.push(t.none(sql, values));
+            }
+          }
+          if (threadIdsToUpdate.size > 0) {
+            const threadIds = Array.from(threadIdsToUpdate);
+            queries.push(
+              t.none(
+                `UPDATE ${getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN (${inPlaceholders(threadIds.length)})`,
+                threadIds
+              )
+            );
+          }
+          if (queries.length > 0) {
+            await t.batch(queries);
+          }
+        });
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(
+            `updateMessages retry ${attempt} for ${messageIds.length} messages after ${delay}ms: ${error.message}`
+          );
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIdsLength: messageIds.length
+          }
+        },
+        error$1
+      );
+    });
+    const updatedMessages = await this.#db.client.manyOrNone(selectQuery, messageIds);
+    return (updatedMessages || []).map((row) => {
+      const message = this.normalizeMessageRow(row);
+      if (typeof message.content === "string") {
+        try {
+          return { ...message, content: JSON.parse(message.content) };
+        } catch {
+        }
+      }
+      return message;
+    });
+  }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    const messageTableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.#schema) });
+    const threadTableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.#schema) });
+    await withRetry(
+      async () => {
+        await this.#db.client.tx(async (t) => {
+          const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(",");
+          const messages = await t.manyOrNone(
+            `SELECT DISTINCT thread_id FROM ${messageTableName} WHERE id IN (${placeholders})`,
+            messageIds
+          );
+          const threadIds = messages?.map((msg) => msg.thread_id).filter(Boolean) || [];
+          await t.none(`DELETE FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds);
+          if (threadIds.length > 0) {
+            const updatePromises = threadIds.map(
+              (threadId) => t.none(`UPDATE ${threadTableName} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $1`, [
+                threadId
+              ])
+            );
+            await Promise.all(updatePromises);
+          }
+        });
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(
+            `deleteMessages retry ${attempt} for ${messageIds.length} messages after ${delay}ms: ${error.message}`
+          );
+        }
+      }
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
+    });
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE id = $1`,
+        [resourceId]
+      );
+      if (!result) {
+        return null;
+      }
+      return {
+        id: result.id,
+        createdAt: result.createdAtZ || result.createdAt,
+        updatedAt: result.updatedAtZ || result.updatedAt,
+        workingMemory: result.workingMemory,
+        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_RESOURCE_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    await this.#db.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const tableName = getTableName2({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName2(this.#schema) });
+    const { result } = await withRetry(
+      async () => {
+        const existingResource = await this.getResourceById({ resourceId });
+        if (!existingResource) {
+          const newResource = {
+            id: resourceId,
+            workingMemory,
+            metadata: metadata || {},
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          return this.saveResource({ resource: newResource });
+        }
+        const updatedResource = {
+          ...existingResource,
+          workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+          metadata: {
+            ...existingResource.metadata,
+            ...metadata
+          },
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        const updates = [];
+        const values = [];
+        let paramIndex = 1;
+        if (workingMemory !== void 0) {
+          updates.push(`"workingMemory" = $${paramIndex}`);
+          values.push(workingMemory);
+          paramIndex++;
+        }
+        if (metadata) {
+          updates.push(`metadata = $${paramIndex}`);
+          values.push(JSON.stringify(updatedResource.metadata));
+          paramIndex++;
+        }
+        updates.push(`"updatedAt" = $${paramIndex}`);
+        values.push(updatedResource.updatedAt.toISOString());
+        paramIndex++;
+        updates.push(`"updatedAtZ" = $${paramIndex}`);
+        values.push(updatedResource.updatedAt.toISOString());
+        paramIndex++;
+        values.push(resourceId);
+        await this.#db.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
+        return updatedResource;
+      },
+      {
+        onRetry: (error, attempt, delay) => {
+          this.logger?.warn?.(`updateResource retry ${attempt} for ${resourceId} after ${delay}ms: ${error.message}`);
+        }
+      }
+    ).catch((error$1) => {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_RESOURCE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            resourceId
+          }
+        },
+        error$1
+      );
+    });
+    return result;
+  }
+};
+var ObservabilityDSQL = class _ObservabilityDSQL extends storage.ObservabilityStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_SPANS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolveDsqlConfig(config);
+    this.#db = new DsqlDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _ObservabilityDSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_SPANS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SPANS] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the observability domain tables.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["traceId", "startedAt"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_parentspanid_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["parentSpanId", "startedAt"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_name_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["name"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_spantype_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["spanType", "startedAt"]
+      },
+      // Entity identification indexes - common filtering patterns
+      {
+        name: `${schemaPrefix}mastra_ai_spans_entitytype_entityid_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["entityType", "entityId"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_entitytype_entityname_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["entityType", "entityName"]
+      },
+      // Multi-tenant filtering - organizationId + userId
+      {
+        name: `${schemaPrefix}mastra_ai_spans_orgid_userid_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["organizationId", "userId"]
+      }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_SPANS });
+  }
+  get tracingStrategy() {
+    return {
+      preferred: "batch-with-updates",
+      supported: ["batch-with-updates", "insert-only"]
+    };
+  }
+  async createSpan(args) {
+    const { span } = args;
+    try {
+      const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
+      const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const record = {
+        ...span,
+        startedAt,
+        endedAt,
+        startedAtZ: startedAt,
+        endedAtZ: endedAt,
+        // Aurora DSQL doesn't support triggers, so we set timestamps explicitly
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.#db.insert({ tableName: storage.TABLE_SPANS, record });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "CREATE_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            spanName: span.name
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getSpan(args) {
+    const { traceId, spanId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const row = await this.#db.client.oneOrNone(
+        `SELECT
+          "traceId", "spanId", "parentSpanId", "name",
+          "entityType", "entityId", "entityName",
+          "userId", "organizationId", "resourceId",
+          "runId", "sessionId", "threadId", "requestId",
+          "environment", "source", "serviceName", "scope",
+          "spanType", "attributes", "metadata", "tags", "links",
+          "input", "output", "error", "isEvent",
+          "startedAtZ" as "startedAt", "endedAtZ" as "endedAt",
+          "createdAtZ" as "createdAt", "updatedAtZ" as "updatedAt"
+        FROM ${tableName}
+        WHERE "traceId" = $1 AND "spanId" = $2`,
+        [traceId, spanId]
+      );
+      if (!row) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({
+          tableName: storage.TABLE_SPANS,
+          sqlRow: row
+        })
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId, spanId }
+        },
+        error$1
+      );
+    }
+  }
+  async getRootSpan(args) {
+    const { traceId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const row = await this.#db.client.oneOrNone(
+        `SELECT
+          "traceId", "spanId", "parentSpanId", "name",
+          "entityType", "entityId", "entityName",
+          "userId", "organizationId", "resourceId",
+          "runId", "sessionId", "threadId", "requestId",
+          "environment", "source", "serviceName", "scope",
+          "spanType", "attributes", "metadata", "tags", "links",
+          "input", "output", "error", "isEvent",
+          "startedAtZ" as "startedAt", "endedAtZ" as "endedAt",
+          "createdAtZ" as "createdAt", "updatedAtZ" as "updatedAt"
+        FROM ${tableName}
+        WHERE "traceId" = $1 AND "parentSpanId" IS NULL`,
+        [traceId]
+      );
+      if (!row) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({
+          tableName: storage.TABLE_SPANS,
+          sqlRow: row
+        })
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_ROOT_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId }
+        },
+        error$1
+      );
+    }
+  }
+  async getTrace(args) {
+    const { traceId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const spans = await this.#db.client.manyOrNone(
+        `SELECT
+          "traceId", "spanId", "parentSpanId", "name",
+          "entityType", "entityId", "entityName",
+          "userId", "organizationId", "resourceId",
+          "runId", "sessionId", "threadId", "requestId",
+          "environment", "source", "serviceName", "scope",
+          "spanType", "attributes", "metadata", "tags", "links",
+          "input", "output", "error", "isEvent",
+          "startedAtZ" as "startedAt", "endedAtZ" as "endedAt",
+          "createdAtZ" as "createdAt", "updatedAtZ" as "updatedAt"
+        FROM ${tableName}
+        WHERE "traceId" = $1
+        ORDER BY "startedAtZ" ASC`,
+        [traceId]
+      );
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map(
+          (span) => transformFromSqlRow({
+            tableName: storage.TABLE_SPANS,
+            sqlRow: span
+          })
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_TRACE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateSpan(args) {
+    const { traceId, spanId, updates } = args;
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        const endedAt = data.endedAt.toISOString();
+        data.endedAt = endedAt;
+        data.endedAtZ = endedAt;
+      }
+      if (data.startedAt instanceof Date) {
+        const startedAt = data.startedAt.toISOString();
+        data.startedAt = startedAt;
+        data.startedAtZ = startedAt;
+      }
+      await this.#db.update({
+        tableName: storage.TABLE_SPANS,
+        keys: { spanId, traceId },
+        data
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId,
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listTraces(args) {
+    const { filters, pagination, orderBy } = storage.listTracesArgsSchema.parse(args);
+    const page = pagination?.page ?? 0;
+    const perPage = pagination?.perPage ?? 100;
+    const tableName = getTableName2({
+      indexName: storage.TABLE_SPANS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    try {
+      const conditions = ['r."parentSpanId" IS NULL'];
+      const params = [];
+      let paramIndex = 1;
+      if (filters) {
+        if (filters.startedAt?.start) {
+          conditions.push(`r."startedAtZ" >= $${paramIndex++}`);
+          params.push(filters.startedAt.start.toISOString());
+        }
+        if (filters.startedAt?.end) {
+          conditions.push(`r."startedAtZ" <= $${paramIndex++}`);
+          params.push(filters.startedAt.end.toISOString());
+        }
+        if (filters.endedAt?.start) {
+          conditions.push(`r."endedAtZ" >= $${paramIndex++}`);
+          params.push(filters.endedAt.start.toISOString());
+        }
+        if (filters.endedAt?.end) {
+          conditions.push(`r."endedAtZ" <= $${paramIndex++}`);
+          params.push(filters.endedAt.end.toISOString());
+        }
+        if (filters.spanType !== void 0) {
+          conditions.push(`r."spanType" = $${paramIndex++}`);
+          params.push(filters.spanType);
+        }
+        if (filters.entityType !== void 0) {
+          conditions.push(`r."entityType" = $${paramIndex++}`);
+          params.push(filters.entityType);
+        }
+        if (filters.entityId !== void 0) {
+          conditions.push(`r."entityId" = $${paramIndex++}`);
+          params.push(filters.entityId);
+        }
+        if (filters.entityName !== void 0) {
+          conditions.push(`r."entityName" = $${paramIndex++}`);
+          params.push(filters.entityName);
+        }
+        if (filters.userId !== void 0) {
+          conditions.push(`r."userId" = $${paramIndex++}`);
+          params.push(filters.userId);
+        }
+        if (filters.organizationId !== void 0) {
+          conditions.push(`r."organizationId" = $${paramIndex++}`);
+          params.push(filters.organizationId);
+        }
+        if (filters.resourceId !== void 0) {
+          conditions.push(`r."resourceId" = $${paramIndex++}`);
+          params.push(filters.resourceId);
+        }
+        if (filters.runId !== void 0) {
+          conditions.push(`r."runId" = $${paramIndex++}`);
+          params.push(filters.runId);
+        }
+        if (filters.sessionId !== void 0) {
+          conditions.push(`r."sessionId" = $${paramIndex++}`);
+          params.push(filters.sessionId);
+        }
+        if (filters.threadId !== void 0) {
+          conditions.push(`r."threadId" = $${paramIndex++}`);
+          params.push(filters.threadId);
+        }
+        if (filters.requestId !== void 0) {
+          conditions.push(`r."requestId" = $${paramIndex++}`);
+          params.push(filters.requestId);
+        }
+        if (filters.environment !== void 0) {
+          conditions.push(`r."environment" = $${paramIndex++}`);
+          params.push(filters.environment);
+        }
+        if (filters.source !== void 0) {
+          conditions.push(`r."source" = $${paramIndex++}`);
+          params.push(filters.source);
+        }
+        if (filters.serviceName !== void 0) {
+          conditions.push(`r."serviceName" = $${paramIndex++}`);
+          params.push(filters.serviceName);
+        }
+        if (filters.scope != null) {
+          conditions.push(`r."scope"::text = $${paramIndex++}`);
+          params.push(JSON.stringify(filters.scope));
+        }
+        if (filters.metadata != null) {
+          conditions.push(`r."metadata"::text = $${paramIndex++}`);
+          params.push(JSON.stringify(filters.metadata));
+        }
+        if (filters.tags != null && filters.tags.length > 0) {
+          conditions.push(`r."tags"::text = $${paramIndex++}`);
+          params.push(JSON.stringify(filters.tags));
+        }
+        if (filters.status !== void 0) {
+          switch (filters.status) {
+            case storage.TraceStatus.ERROR:
+              conditions.push(`r."error" IS NOT NULL`);
+              break;
+            case storage.TraceStatus.RUNNING:
+              conditions.push(`r."endedAtZ" IS NULL AND r."error" IS NULL`);
+              break;
+            case storage.TraceStatus.SUCCESS:
+              conditions.push(`r."endedAtZ" IS NOT NULL AND r."error" IS NULL`);
+              break;
+          }
+        }
+        if (filters.hasChildError !== void 0) {
+          if (filters.hasChildError) {
+            conditions.push(`EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c."traceId" = r."traceId" AND c."error" IS NOT NULL
+            )`);
+          } else {
+            conditions.push(`NOT EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c."traceId" = r."traceId" AND c."error" IS NOT NULL
+            )`);
+          }
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sortField = `${orderBy?.field ?? "startedAt"}Z`;
+      const sortDirection = orderBy?.direction ?? "DESC";
+      const orderClause = `ORDER BY r."${sortField}" ${sortDirection}`;
+      const countResult = await this.#db.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${tableName} r ${whereClause}`,
+        params
+      );
+      const count = Number(countResult?.count ?? 0);
+      if (count === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage,
+            hasMore: false
+          },
+          spans: []
+        };
+      }
+      const spans = await this.#db.client.manyOrNone(
+        `SELECT
+          r."traceId", r."spanId", r."parentSpanId", r."name",
+          r."entityType", r."entityId", r."entityName",
+          r."userId", r."organizationId", r."resourceId",
+          r."runId", r."sessionId", r."threadId", r."requestId",
+          r."environment", r."source", r."serviceName", r."scope",
+          r."spanType", r."attributes", r."metadata", r."tags", r."links",
+          r."input", r."output", r."error", r."isEvent",
+          r."startedAtZ" as "startedAt", r."endedAtZ" as "endedAt",
+          r."createdAtZ" as "createdAt", r."updatedAtZ" as "updatedAt"
+        FROM ${tableName} r
+        ${whereClause}
+        ${orderClause}
+        LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+        [...params, perPage, page * perPage]
+      );
+      return {
+        pagination: {
+          total: count,
+          page,
+          perPage,
+          hasMore: (page + 1) * perPage < count
+        },
+        spans: storage.toTraceSpans(
+          spans.map(
+            (span) => transformFromSqlRow({
+              tableName: storage.TABLE_SPANS,
+              sqlRow: span
+            })
+          )
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_TRACES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchCreateSpans(args) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const records = args.records.map((record) => {
+        const startedAt = record.startedAt instanceof Date ? record.startedAt.toISOString() : record.startedAt;
+        const endedAt = record.endedAt instanceof Date ? record.endedAt.toISOString() : record.endedAt;
+        return {
+          ...record,
+          startedAt,
+          endedAt,
+          startedAtZ: startedAt,
+          endedAtZ: endedAt,
+          // Aurora DSQL doesn't support triggers, so we set timestamps explicitly
+          createdAt: now,
+          updatedAt: now
+        };
+      });
+      await this.#db.batchInsert({
+        tableName: storage.TABLE_SPANS,
+        records
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "BATCH_CREATE_SPANS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchUpdateSpans(args) {
+    try {
+      await this.#db.batchUpdate({
+        tableName: storage.TABLE_SPANS,
+        updates: args.records.map((record) => {
+          const data = { ...record.updates };
+          if (data.endedAt instanceof Date) {
+            const endedAt = data.endedAt.toISOString();
+            data.endedAt = endedAt;
+            data.endedAtZ = endedAt;
+          }
+          if (data.startedAt instanceof Date) {
+            const startedAt = data.startedAt.toISOString();
+            data.startedAt = startedAt;
+            data.startedAtZ = startedAt;
+          }
+          return {
+            keys: { spanId: record.spanId, traceId: record.traceId },
+            data
+          };
+        })
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "BATCH_UPDATE_SPANS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchDeleteTraces(args) {
+    const { batches } = splitIntoBatches(args.traceIds, { maxRows: DEFAULT_MAX_ROWS_PER_BATCH });
+    const tableName = getTableName2({
+      indexName: storage.TABLE_SPANS,
+      schemaName: getSchemaName2(this.#schema)
+    });
+    for (const batchTraceIds of batches) {
+      const placeholders = batchTraceIds.map((_, i) => `$${i + 1}`).join(", ");
+      await withRetry(
+        async () => {
+          await this.#db.client.none(`DELETE FROM ${tableName} WHERE "traceId" IN (${placeholders})`, batchTraceIds);
+        },
+        {
+          onRetry: (error, attempt, delay) => {
+            this.logger?.warn?.(
+              `batchDeleteTraces retry ${attempt} for ${batchTraceIds.length} traces after ${delay}ms: ${error.message}`
+            );
+          }
+        }
+      ).catch((error$1) => {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("DSQL", "BATCH_DELETE_TRACES", "FAILED"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.USER
+          },
+          error$1
+        );
+      });
+    }
+  }
+};
+function transformScoreRow(row) {
+  return storage.transformScoreRow(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
+}
+var ScoresDSQL = class _ScoresDSQL extends storage.ScoresStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_SCORERS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolveDsqlConfig(config);
+    this.#db = new DsqlDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _ScoresDSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the scores domain tables.
+   * Note: Aurora DSQL does not support ASC/DESC in index columns.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_scores_trace_id_span_id_created_at_idx`,
+        table: storage.TABLE_SCORERS,
+        columns: ["traceId", "spanId", "createdAt"]
+      }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_SCORERS });
+  }
+  async getScoreById({ id }) {
+    try {
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE id = $1`,
+        [id]
+      );
+      return result ? transformScoreRow(result) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_SCORE_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    try {
+      const conditions = [`"scorerId" = $1`];
+      const queryParams = [scorerId];
+      let paramIndex = 2;
+      if (entityId) {
+        conditions.push(`"entityId" = $${paramIndex++}`);
+        queryParams.push(entityId);
+      }
+      if (entityType) {
+        conditions.push(`"entityType" = $${paramIndex++}`);
+        queryParams.push(entityType);
+      }
+      if (source) {
+        conditions.push(`"source" = $${paramIndex++}`);
+        queryParams.push(source);
+      }
+      const whereClause = conditions.join(" AND ");
+      const total = await this.#db.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE ${whereClause}`,
+        queryParams
+      );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (total?.count === "0" || !total?.count) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
+      const result = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
+        [...queryParams, limitValue, start]
+      );
+      return {
+        pagination: {
+          total: Number(total?.count) || 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
+        },
+        scores: result.map(transformScoreRow)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_SCORES_BY_SCORER_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    let parsedScore;
+    try {
+      parsedScore = evals.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "SAVE_SCORE", "VALIDATION_FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
+        },
+        error$1
+      );
+    }
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const {
+        scorer,
+        preprocessStepResult,
+        analyzeStepResult,
+        metadata,
+        input,
+        output,
+        additionalContext,
+        requestContext,
+        entity,
+        ...rest
+      } = parsedScore;
+      await this.#db.insert({
+        tableName: storage.TABLE_SCORERS,
+        record: {
+          id,
+          ...rest,
+          input: JSON.stringify(input) || "",
+          output: JSON.stringify(output) || "",
+          scorer: scorer ? JSON.stringify(scorer) : null,
+          preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
+          analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
+          metadata: metadata ? JSON.stringify(metadata) : null,
+          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
+          requestContext: requestContext ? JSON.stringify(requestContext) : null,
+          entity: entity ? JSON.stringify(entity) : null,
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
+        }
+      });
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "SAVE_SCORE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const total = await this.#db.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE "runId" = $1`,
+        [runId]
+      );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (total?.count === "0" || !total?.count) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
+      const result = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE "runId" = $1 ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`,
+        [runId, limitValue, start]
+      );
+      return {
+        pagination: {
+          total: Number(total?.count) || 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
+        },
+        scores: result.map(transformScoreRow)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_SCORES_BY_RUN_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    try {
+      const total = await this.#db.client.oneOrNone(
+        `SELECT COUNT(*) FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2`,
+        [entityId, entityType]
+      );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      if (total?.count === "0" || !total?.count) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
+      const result = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) })} WHERE "entityId" = $1 AND "entityType" = $2 ORDER BY "createdAt" DESC LIMIT $3 OFFSET $4`,
+        [entityId, entityType, limitValue, start]
+      );
+      return {
+        pagination: {
+          total: Number(total?.count) || 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
+        },
+        scores: result.map(transformScoreRow)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_SCORES_BY_ENTITY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.#schema) });
+      const countSQLResult = await this.#db.client.oneOrNone(
+        `SELECT COUNT(*) as count FROM ${tableName} WHERE "traceId" = $1 AND "spanId" = $2`,
+        [traceId, spanId]
+      );
+      const total = Number(countSQLResult?.count ?? 0);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "traceId" = $1 AND "spanId" = $2 ORDER BY "createdAt" DESC LIMIT $3 OFFSET $4`,
+        [traceId, spanId, limitValue, start]
+      );
+      const hasMore = end < total;
+      const scores = result.map((row) => transformScoreRow(row)) ?? [];
+      return {
+        scores,
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_SCORES_BY_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    resourceId: row.resourceId,
+    createdAt: new Date(row.createdAtZ || row.createdAt),
+    updatedAt: new Date(row.updatedAtZ || row.updatedAt)
+  };
+}
+var WorkflowsDSQL = class _WorkflowsDSQL extends storage.WorkflowsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_WORKFLOW_SNAPSHOT];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolveDsqlConfig(config);
+    this.#db = new DsqlDB({ client, schemaName });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _WorkflowsDSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  supportsConcurrentUpdates() {
+    return true;
+  }
+  /**
+   * Returns default index definitions for the workflows domain tables.
+   * Currently no default indexes are defined for workflows.
+   */
+  getDefaultIndexDefinitions() {
+    return [];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   * Currently no default indexes are defined for workflows.
+   */
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT] });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT],
+      ifNotExists: ["resourceId"]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    try {
+      const { result: context } = await withRetry(
+        async () => {
+          return this.#db.client.tx(async (t) => {
+            const tableName = getTableName2({
+              indexName: storage.TABLE_WORKFLOW_SNAPSHOT,
+              schemaName: getSchemaName2(this.#schema)
+            });
+            const existingSnapshotResult = await t.oneOrNone(
+              `SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2`,
+              [workflowName, runId]
+            );
+            let snapshot;
+            if (!existingSnapshotResult) {
+              snapshot = {
+                context: {},
+                activePaths: [],
+                timestamp: Date.now(),
+                suspendedPaths: {},
+                activeStepsPath: {},
+                resumeLabels: {},
+                serializedStepGraph: [],
+                status: "pending",
+                value: {},
+                waitingPaths: {},
+                runId,
+                requestContext: {}
+              };
+            } else {
+              const existingSnapshot = existingSnapshotResult.snapshot;
+              snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+            }
+            snapshot.context[stepId] = result;
+            snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+            const now = /* @__PURE__ */ new Date();
+            await t.none(
+              `INSERT INTO ${tableName} (workflow_name, run_id, snapshot, "createdAt", "updatedAt")
+               VALUES ($1, $2, $3, $4, $5)
+               ON CONFLICT (workflow_name, run_id) DO UPDATE
+               SET snapshot = $3, "updatedAt" = $5`,
+              [workflowName, runId, JSON.stringify(snapshot), now, now]
+            );
+            return snapshot.context;
+          });
+        },
+        {
+          onRetry: (error, attempt, delay) => {
+            this.logger?.warn?.(
+              `updateWorkflowResults retry ${attempt} for workflow ${workflowName}/${runId} after ${delay}ms: ${error.message}`
+            );
+          }
+        }
+      );
+      return context;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId,
+            stepId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    try {
+      const { result } = await withRetry(
+        async () => {
+          return this.#db.client.tx(async (t) => {
+            const tableName = getTableName2({
+              indexName: storage.TABLE_WORKFLOW_SNAPSHOT,
+              schemaName: getSchemaName2(this.#schema)
+            });
+            const existingSnapshotResult = await t.oneOrNone(
+              `SELECT snapshot FROM ${tableName} WHERE workflow_name = $1 AND run_id = $2`,
+              [workflowName, runId]
+            );
+            if (!existingSnapshotResult) {
+              return void 0;
+            }
+            const existingSnapshot = existingSnapshotResult.snapshot;
+            const snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+            if (!snapshot || !snapshot?.context) {
+              throw new Error(`Snapshot not found for runId ${runId}`);
+            }
+            const updatedSnapshot = { ...snapshot, ...opts };
+            await t.none(
+              `UPDATE ${tableName} SET snapshot = $1, "updatedAt" = $2 WHERE workflow_name = $3 AND run_id = $4`,
+              [JSON.stringify(updatedSnapshot), /* @__PURE__ */ new Date(), workflowName, runId]
+            );
+            return updatedSnapshot;
+          });
+        },
+        {
+          onRetry: (error, attempt, delay) => {
+            this.logger?.warn?.(
+              `updateWorkflowState retry ${attempt} for workflow ${workflowName}/${runId} after ${delay}ms: ${error.message}`
+            );
+          }
+        }
+      );
+      return result;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "UPDATE_WORKFLOW_STATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot,
+    createdAt,
+    updatedAt
+  }) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const createdAtValue = createdAt ? createdAt : now;
+      const updatedAtValue = updatedAt ? updatedAt : now;
+      await this.#db.client.none(
+        `INSERT INTO ${getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.#schema) })} (workflow_name, run_id, "resourceId", snapshot, "createdAt", "updatedAt")
+                 VALUES ($1, $2, $3, $4, $5, $6)
+                 ON CONFLICT (workflow_name, run_id) DO UPDATE
+                 SET "resourceId" = $3, snapshot = $4, "updatedAt" = $6`,
+        [
+          workflowName,
+          runId,
+          resourceId,
+          JSON.stringify(snapshot),
+          createdAtValue.toISOString(),
+          updatedAtValue.toISOString()
+        ]
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const result = await this.#db.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: { workflow_name: workflowName, run_id: runId }
+      });
+      return result ? result.snapshot : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const conditions = [];
+      const values = [];
+      let paramIndex = 1;
+      if (runId) {
+        conditions.push(`run_id = $${paramIndex}`);
+        values.push(runId);
+        paramIndex++;
+      }
+      if (workflowName) {
+        conditions.push(`workflow_name = $${paramIndex}`);
+        values.push(workflowName);
+        paramIndex++;
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const query = `
+          SELECT * FROM ${getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.#schema) })}
+          ${whereClause}
+          ORDER BY "createdAt" DESC LIMIT 1
+        `;
+      const queryValues = values;
+      const result = await this.#db.client.oneOrNone(query, queryValues);
+      if (!result) {
+        return null;
+      }
+      return parseWorkflowRun(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    try {
+      await this.#db.client.none(
+        `DELETE FROM ${getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.#schema) })} WHERE run_id = $1 AND workflow_name = $2`,
+        [runId, workflowName]
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async listWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    perPage,
+    page,
+    resourceId,
+    status
+  } = {}) {
+    try {
+      const conditions = [];
+      const values = [];
+      let paramIndex = 1;
+      if (workflowName) {
+        conditions.push(`workflow_name = $${paramIndex}`);
+        values.push(workflowName);
+        paramIndex++;
+      }
+      if (status) {
+        conditions.push(`snapshot::jsonb ->> 'status' = $${paramIndex}`);
+        values.push(status);
+        paramIndex++;
+      }
+      if (resourceId) {
+        const hasResourceId = await this.#db.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        if (hasResourceId) {
+          conditions.push(`"resourceId" = $${paramIndex}`);
+          values.push(resourceId);
+          paramIndex++;
+        } else {
+          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+        }
+      }
+      if (fromDate) {
+        conditions.push(`"createdAt" >= $${paramIndex}`);
+        values.push(fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+        paramIndex++;
+      }
+      if (toDate) {
+        conditions.push(`"createdAt" <= $${paramIndex}`);
+        values.push(toDate instanceof Date ? toDate.toISOString() : toDate);
+        paramIndex++;
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      let total = 0;
+      const usePagination = typeof perPage === "number" && typeof page === "number";
+      if (usePagination) {
+        const countResult = await this.#db.client.one(
+          `SELECT COUNT(*) as count FROM ${getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.#schema) })} ${whereClause}`,
+          values
+        );
+        total = Number(countResult.count);
+      }
+      const normalizedPerPage = usePagination ? storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
+      const offset = usePagination ? page * normalizedPerPage : void 0;
+      const query = `
+          SELECT * FROM ${getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.#schema) })}
+          ${whereClause}
+          ORDER BY "createdAt" DESC
+          ${usePagination ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
+        `;
+      const queryValues = usePagination ? [...values, normalizedPerPage, offset] : values;
+      const result = await this.#db.client.manyOrNone(query, queryValues);
+      const runs = (result || []).map((row) => {
+        return parseWorkflowRun(row);
+      });
+      return { runs, total: total || runs.length };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "LIST_WORKFLOW_RUNS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName: workflowName || "all"
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// src/storage/index.ts
+var DSQLStore = class extends storage.MastraStorage {
+  #pool;
+  #db;
+  #ownsPool;
+  schema;
+  isInitialized = false;
+  stores;
+  constructor(config) {
+    try {
+      validateConfig(config);
+      super({ id: config.id, name: "DSQLStore", disableInit: config.disableInit });
+      this.schema = config.schemaName || "public";
+      if (isPoolConfig(config)) {
+        this.#pool = config.pool;
+        this.#ownsPool = false;
+      } else {
+        this.#pool = this.createPool(config);
+        this.#ownsPool = true;
+      }
+      this.#db = new PoolAdapter(this.#pool);
+      const domainConfig = {
+        client: this.#db,
+        schemaName: this.schema,
+        skipDefaultIndexes: config.skipDefaultIndexes,
+        indexes: config.indexes
+      };
+      this.stores = {
+        scores: new ScoresDSQL(domainConfig),
+        workflows: new WorkflowsDSQL(domainConfig),
+        memory: new MemoryDSQL(domainConfig),
+        observability: new ObservabilityDSQL(domainConfig),
+        agents: new AgentsDSQL(domainConfig)
+      };
+    } catch (e) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INITIALIZATION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        e
+      );
+    }
+  }
+  /**
+   * Creates a connection pool with AuroraDSQLClient for IAM authentication.
+   */
+  createPool(config) {
+    if (!isHostConfig(config)) {
+      throw new Error("DSQLStore: Invalid configuration for creating pool.");
+    }
+    const region = getEffectiveRegion(config);
+    const poolConfig = {
+      host: config.host,
+      user: config.user ?? "admin",
+      database: config.database ?? "postgres",
+      // Use AuroraDSQLClient for automatic IAM token generation
+      Client: auroraDsqlNodePostgresConnector.AuroraDSQLClient,
+      // Pass region for IAM token generation
+      region,
+      // Custom credentials provider (optional)
+      customCredentialsProvider: config.customCredentialsProvider,
+      // Pool settings optimized for Aurora DSQL
+      max: config.max ?? DSQL_POOL_DEFAULTS.max,
+      min: config.min ?? DSQL_POOL_DEFAULTS.min,
+      idleTimeoutMillis: config.idleTimeoutMillis ?? DSQL_POOL_DEFAULTS.idleTimeoutMillis,
+      maxLifetimeSeconds: config.maxLifetimeSeconds ?? DSQL_POOL_DEFAULTS.maxLifetimeSeconds,
+      connectionTimeoutMillis: config.connectionTimeoutMillis ?? DSQL_POOL_DEFAULTS.connectionTimeoutMillis,
+      allowExitOnIdle: config.allowExitOnIdle ?? DSQL_POOL_DEFAULTS.allowExitOnIdle
+    };
+    return new pg.Pool(poolConfig);
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    try {
+      this.isInitialized = true;
+      await super.init();
+    } catch (error$1) {
+      this.isInitialized = false;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("DSQL", "INIT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Database client for executing queries.
+   *
+   * @example
+   * ```typescript
+   * const rows = await store.db.any('SELECT * FROM users WHERE active = $1', [true]);
+   * const user = await store.db.one('SELECT * FROM users WHERE id = $1', [userId]);
+   * ```
+   */
+  get db() {
+    return this.#db;
+  }
+  /**
+   * The underlying pg.Pool for direct database access or ORM integration.
+   */
+  get pool() {
+    return this.#pool;
+  }
+  /**
+   * Closes the connection pool if it was created by this store.
+   * If a pool was passed in via config, it will not be closed.
+   */
+  async close() {
+    if (this.#ownsPool) {
+      await this.#pool.end();
+    }
+    this.isInitialized = false;
+  }
+};
+
+exports.AgentsDSQL = AgentsDSQL;
+exports.DSQLStore = DSQLStore;
+exports.DSQL_POOL_DEFAULTS = DSQL_POOL_DEFAULTS;
+exports.MemoryDSQL = MemoryDSQL;
+exports.ObservabilityDSQL = ObservabilityDSQL;
+exports.PoolAdapter = PoolAdapter;
+exports.ScoresDSQL = ScoresDSQL;
+exports.WorkflowsDSQL = WorkflowsDSQL;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map