@mastra/convex 1.4.0 → 1.5.0

package/dist/chunk-2KILIA33.cjs

@@ -1,1776 +0,0 @@
-'use strict';
-
-var server = require('convex/server');
-var constants = require('@mastra/core/storage/constants');
-var values = require('convex/values');
-
-// src/server/cache.ts
-var CACHE_TABLE = "mastra_cache";
-var CACHE_LIST_TABLE = "mastra_cache_list_items";
-var CACHE_MUTATION_BATCH_SIZE = 25;
-function encodeValue(value) {
-  return JSON.stringify(value === void 0 ? null : value);
-}
-function decodeValue(value) {
-  return JSON.parse(value);
-}
-function isExpired(doc, now) {
-  return doc.expiresAt !== null && doc.expiresAt <= now;
-}
-function normalizeListRange(from, to, length) {
-  const normalizedFrom = from < 0 ? Math.max(length + from, 0) : from;
-  const normalizedTo = to < 0 ? length + to : to;
-  if (normalizedTo < normalizedFrom || normalizedFrom >= length) return null;
-  return { from: normalizedFrom, to: normalizedTo };
-}
-async function findCacheDoc(ctx, key) {
-  return await ctx.db.query(CACHE_TABLE).withIndex("by_key", (q) => q.eq("key", key)).first();
-}
-async function deleteCacheKey(ctx, key) {
-  const [doc, listItems] = await Promise.all([
-    findCacheDoc(ctx, key),
-    ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => q.eq("key", key)).take(CACHE_MUTATION_BATCH_SIZE + 1)
-  ]);
-  if (doc && doc.kind !== "deleted") {
-    await ctx.db.patch(doc._id, { kind: "deleted" });
-  }
-  for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
-    await ctx.db.delete(item._id);
-  }
-  const hasMore = listItems.length > CACHE_MUTATION_BATCH_SIZE;
-  if (doc && !hasMore) {
-    await ctx.db.delete(doc._id);
-  }
-  return {
-    hasMore
-  };
-}
-async function getLiveCacheDoc(ctx, key, now) {
-  const doc = await findCacheDoc(ctx, key);
-  if (!doc) return { doc: null, hasMore: false };
-  if (doc.kind === "deleted") {
-    const cleanup2 = await deleteCacheKey(ctx, key);
-    return { doc: null, hasMore: cleanup2.hasMore };
-  }
-  if (!isExpired(doc, now)) return { doc, hasMore: false };
-  const cleanup = await deleteCacheKey(ctx, key);
-  return { doc: null, hasMore: cleanup.hasMore };
-}
-async function writeCacheDoc(ctx, key, existing, patch) {
-  if (existing) {
-    await ctx.db.patch(existing._id, patch);
-    return { ...existing, ...patch };
-  }
-  const _id = await ctx.db.insert(CACHE_TABLE, { key, ...patch });
-  return { _id, key, ...patch };
-}
-async function clearPrefix(ctx, keyPrefix) {
-  const [docs, orphanListItems] = await Promise.all([
-    ctx.db.query(CACHE_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(CACHE_MUTATION_BATCH_SIZE + 1),
-    ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(1)
-  ]);
-  if (docs.length > 0) {
-    for (const doc of docs.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
-      if (doc.kind === "list" || doc.kind === "deleted") {
-        const cleanup = await deleteCacheKey(ctx, doc.key);
-        return cleanup.hasMore || docs.length > 1 || orphanListItems.length > 0;
-      }
-      await ctx.db.delete(doc._id);
-    }
-    return docs.length > CACHE_MUTATION_BATCH_SIZE || orphanListItems.length > 0;
-  }
-  const listItems = await ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(CACHE_MUTATION_BATCH_SIZE + 1);
-  for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
-    await ctx.db.delete(item._id);
-  }
-  return listItems.length > CACHE_MUTATION_BATCH_SIZE;
-}
-async function handleCacheOperation(ctx, request) {
-  const now = Date.now();
-  switch (request.op) {
-    case "get": {
-      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
-      if (hasMore) return { ok: true, result: null, hasMore: true };
-      if (!doc || doc.kind !== "value") return { ok: true, result: null };
-      return { ok: true, result: decodeValue(doc.value ?? "null") };
-    }
-    case "set": {
-      let existing = await findCacheDoc(ctx, request.key);
-      if (existing && (isExpired(existing, now) || existing.kind !== "value")) {
-        const cleanup = await deleteCacheKey(ctx, request.key);
-        if (cleanup.hasMore) {
-          return { ok: true, hasMore: true };
-        }
-        existing = null;
-      }
-      await writeCacheDoc(ctx, request.key, existing, {
-        keyPrefix: request.keyPrefix,
-        kind: "value",
-        value: encodeValue(request.value),
-        expiresAt: request.expiresAt
-      });
-      return { ok: true };
-    }
-    case "listLength": {
-      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
-      if (hasMore) return { ok: true, result: 0, hasMore: true };
-      if (!doc) return { ok: true, result: 0 };
-      if (doc.kind !== "list") return { ok: false, error: `${request.key} exists but is not an array` };
-      return { ok: true, result: doc.counter ?? 0 };
-    }
-    case "listPush": {
-      let existing = await findCacheDoc(ctx, request.key);
-      if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
-        const cleanup = await deleteCacheKey(ctx, request.key);
-        if (cleanup.hasMore) {
-          return { ok: true, hasMore: true };
-        }
-        existing = null;
-      }
-      if (existing && existing.kind !== "list") {
-        return { ok: false, error: `${request.key} exists but is not an array` };
-      }
-      const doc = existing ? await writeCacheDoc(ctx, request.key, existing, {
-        kind: "list",
-        keyPrefix: request.keyPrefix,
-        counter: (existing.counter ?? 0) + 1,
-        expiresAt: request.expiresAt
-      }) : await writeCacheDoc(ctx, request.key, null, {
-        kind: "list",
-        keyPrefix: request.keyPrefix,
-        counter: 1,
-        expiresAt: request.expiresAt
-      });
-      await ctx.db.insert(CACHE_LIST_TABLE, {
-        key: request.key,
-        keyPrefix: request.keyPrefix,
-        index: (doc.counter ?? 1) - 1,
-        value: encodeValue(request.value)
-      });
-      return { ok: true };
-    }
-    case "listFromTo": {
-      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
-      if (hasMore) return { ok: true, result: [], hasMore: true };
-      if (!doc || doc.kind !== "list") return { ok: true, result: [] };
-      const range = normalizeListRange(request.from, request.to, doc.counter ?? 0);
-      if (!range) return { ok: true, result: [] };
-      const query = ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => {
-        return q.eq("key", request.key).gte("index", range.from).lte("index", range.to);
-      });
-      const items = await query.collect();
-      return { ok: true, result: items.map((item) => decodeValue(item.value)) };
-    }
-    case "delete": {
-      const cleanup = await deleteCacheKey(ctx, request.key);
-      return { ok: true, hasMore: cleanup.hasMore };
-    }
-    case "clear": {
-      const hasMore = await clearPrefix(ctx, request.keyPrefix);
-      return { ok: true, hasMore };
-    }
-    case "increment": {
-      let existing = await findCacheDoc(ctx, request.key);
-      if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
-        const cleanup = await deleteCacheKey(ctx, request.key);
-        if (cleanup.hasMore) {
-          return { ok: true, hasMore: true };
-        }
-        existing = null;
-      }
-      if (existing && existing.kind !== "counter") {
-        return { ok: false, error: `${request.key} exists but is not a number` };
-      }
-      const nextCounter = (existing?.counter ?? 0) + 1;
-      await writeCacheDoc(ctx, request.key, existing, {
-        kind: "counter",
-        keyPrefix: request.keyPrefix,
-        counter: nextCounter,
-        expiresAt: request.expiresAt
-      });
-      return { ok: true, result: nextCounter };
-    }
-  }
-  return { ok: false, error: `Unsupported operation ${request.op}` };
-}
-var mastraCache = server.mutationGeneric(
-  async (ctx, request) => handleCacheOperation(ctx, request)
-);
-
-// src/server/index-map.ts
-var TABLE_INDEX_MAP = {
-  mastra_messages: [
-    { name: "by_thread_created", fields: ["thread_id", "createdAt"] },
-    { name: "by_thread", fields: ["thread_id"] },
-    { name: "by_resource", fields: ["resourceId"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_threads: [
-    { name: "by_resource", fields: ["resourceId"] },
-    { name: "by_created", fields: ["createdAt"] },
-    { name: "by_updated", fields: ["updatedAt"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_resources: [
-    { name: "by_updated", fields: ["updatedAt"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_workflow_snapshots: [
-    { name: "by_workflow_run", fields: ["workflow_name", "run_id"] },
-    { name: "by_workflow", fields: ["workflow_name"] },
-    { name: "by_resource", fields: ["resourceId"] },
-    { name: "by_created", fields: ["createdAt"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_scorers: [
-    { name: "by_entity", fields: ["entityId", "entityType"] },
-    { name: "by_scorer", fields: ["scorerId"] },
-    { name: "by_run", fields: ["runId"] },
-    { name: "by_created", fields: ["createdAt"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_schedules: [
-    { name: "by_workflow_status", fields: ["workflow_id", "status"] },
-    { name: "by_workflow_id", fields: ["workflow_id"] },
-    { name: "by_owner", fields: ["owner_type", "owner_id"] },
-    { name: "by_owner_id", fields: ["owner_id"] },
-    { name: "by_status_next_fire_at", fields: ["status", "next_fire_at"] },
-    { name: "by_created", fields: ["created_at"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_schedule_triggers: [
-    { name: "by_schedule_actual", fields: ["schedule_id", "actual_fire_at"] },
-    { name: "by_parent_trigger", fields: ["parent_trigger_id"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_channel_installations: [
-    { name: "by_platform_agent", fields: ["platform", "agentId"] },
-    { name: "by_webhook", fields: ["webhookId"] },
-    { name: "by_platform", fields: ["platform"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_channel_config: [
-    { name: "by_platform", fields: ["platform"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_background_tasks: [
-    { name: "by_agent_status", fields: ["agent_id", "status"] },
-    { name: "by_status_created", fields: ["status", "createdAt"] },
-    { name: "by_run", fields: ["run_id"] },
-    { name: "by_tool_call", fields: ["tool_call_id"] },
-    { name: "by_thread", fields: ["thread_id"] },
-    { name: "by_resource", fields: ["resource_id"] },
-    { name: "by_tool", fields: ["tool_name"] },
-    { name: "by_created", fields: ["createdAt"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_vector_indexes: [
-    { name: "by_name", fields: ["indexName"] },
-    { name: "by_record_id", fields: ["id"] }
-  ],
-  mastra_observational_memory: [
-    { name: "by_lookup_key", fields: ["lookupKey", "generationCount"] },
-    { name: "by_record_id", fields: ["id"] }
-  ]
-};
-function findBestIndex(convexTable, filters) {
-  const indexes = TABLE_INDEX_MAP[convexTable];
-  if (!indexes || filters.length === 0) return null;
-  const filtersByField = /* @__PURE__ */ new Map();
-  for (const f of filters) {
-    filtersByField.set(f.field, f);
-  }
-  let best = null;
-  for (const index of indexes) {
-    let prefixLength = 0;
-    const indexedFilters = [];
-    for (const field of index.fields) {
-      const filter = filtersByField.get(field);
-      if (filter) {
-        prefixLength++;
-        indexedFilters.push(filter);
-      } else {
-        break;
-      }
-    }
-    if (prefixLength > 0 && (!best || prefixLength > best.prefixLength)) {
-      best = { indexName: index.name, indexedFilters, prefixLength };
-    }
-  }
-  return best ? { indexName: best.indexName, indexedFilters: best.indexedFilters } : null;
-}
-
-// src/server/observational-memory.ts
-var OM_QUERY_MAX_DOCS = 1e4;
-function parseStoredChunks(value) {
-  if (typeof value !== "string" || !value) return [];
-  try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function selectActivationBoundary(chunks, opts) {
-  const retentionFloor = opts.messageTokensThreshold * (1 - opts.activationRatio);
-  const targetMessageTokens = Math.max(0, opts.currentPendingTokens - retentionFloor);
-  let cumulativeMessageTokens = 0;
-  let bestOverBoundary = 0;
-  let bestOverTokens = 0;
-  let bestUnderBoundary = 0;
-  let bestUnderTokens = 0;
-  for (let i = 0; i < chunks.length; i++) {
-    cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
-    const boundary = i + 1;
-    if (cumulativeMessageTokens >= targetMessageTokens) {
-      if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
-        bestOverBoundary = boundary;
-        bestOverTokens = cumulativeMessageTokens;
-      }
-    } else {
-      if (cumulativeMessageTokens > bestUnderTokens) {
-        bestUnderBoundary = boundary;
-        bestUnderTokens = cumulativeMessageTokens;
-      }
-    }
-  }
-  const maxOvershoot = retentionFloor * 0.95;
-  const overshoot = bestOverTokens - targetMessageTokens;
-  const remainingAfterOver = opts.currentPendingTokens - bestOverTokens;
-  const remainingAfterUnder = opts.currentPendingTokens - bestUnderTokens;
-  const minRemaining = Math.min(1e3, retentionFloor);
-  if (opts.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) {
-    return bestOverBoundary;
-  }
-  if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
-    return bestOverBoundary;
-  }
-  if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
-    return bestUnderBoundary;
-  }
-  if (bestOverBoundary > 0) {
-    return bestOverBoundary;
-  }
-  return 1;
-}
-function mergeReflectionWithUnreflected(activeObservations, bufferedReflection, reflectedLineCount) {
-  const allLines = (activeObservations || "").split("\n");
-  const unreflectedLines = allLines.slice(reflectedLineCount);
-  const unreflectedContent = unreflectedLines.join("\n").trim();
-  return unreflectedContent ? `${bufferedReflection}
-
-${unreflectedContent}` : bufferedReflection;
-}
-function isPlainObj(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepMergeOMConfig(target, source) {
-  const output = { ...target };
-  for (const key of Object.keys(source)) {
-    const tVal = target[key];
-    const sVal = source[key];
-    if (isPlainObj(tVal) && isPlainObj(sVal)) {
-      output[key] = deepMergeOMConfig(tVal, sVal);
-    } else if (sVal !== void 0) {
-      output[key] = sVal;
-    }
-  }
-  return output;
-}
-function parseJsonObject(value) {
-  if (typeof value !== "string" || !value) return {};
-  try {
-    const parsed = JSON.parse(value);
-    return isPlainObj(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-async function findRecordById(ctx, convexTable, id) {
-  return await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
-}
-function requireRecord(doc, id) {
-  if (!doc) {
-    throw new Error(`Observational memory record not found: ${id}`);
-  }
-  return doc;
-}
-var EMPTY_SWAP_RESULT = {
-  chunksActivated: 0,
-  messageTokensActivated: 0,
-  observationTokensActivated: 0,
-  messagesActivated: 0,
-  activatedCycleIds: [],
-  activatedMessageIds: []
-};
-async function handleObservationalMemoryOperation(ctx, convexTable, request) {
-  switch (request.op) {
-    case "omGetLatest": {
-      const doc = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").first();
-      return { ok: true, result: doc ?? null };
-    }
-    case "omGetHistory": {
-      let docs = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").take(OM_QUERY_MAX_DOCS);
-      if (request.from) {
-        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt >= request.from);
-      }
-      if (request.to) {
-        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt <= request.to);
-      }
-      if (request.offset != null) {
-        docs = docs.slice(request.offset);
-      }
-      return { ok: true, result: docs.slice(0, request.limit) };
-    }
-    case "omUpdateActive": {
-      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
-      const safeTokenCount = Number.isFinite(request.tokenCount) && request.tokenCount >= 0 ? request.tokenCount : 0;
-      await ctx.db.patch(doc._id, {
-        activeObservations: request.observations,
-        lastObservedAt: request.lastObservedAt,
-        // Reset pending tokens since we've now observed them
-        pendingMessageTokens: 0,
-        observationTokenCount: safeTokenCount,
-        totalTokensObserved: Number(doc.totalTokensObserved || 0) + safeTokenCount,
-        observedMessageIds: request.observedMessageIds,
-        updatedAt: request.updatedAt
-      });
-      return { ok: true };
-    }
-    case "omAppendBufferedChunk": {
-      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
-      const chunks = parseStoredChunks(doc.bufferedObservationChunks);
-      chunks.push(request.chunk);
-      const patch = {
-        bufferedObservationChunks: JSON.stringify(chunks),
-        updatedAt: request.updatedAt
-      };
-      if (request.lastBufferedAtTime) {
-        patch.lastBufferedAtTime = request.lastBufferedAtTime;
-      }
-      await ctx.db.patch(doc._id, patch);
-      return { ok: true };
-    }
-    case "omSwapBuffered": {
-      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
-      const persistedChunks = parseStoredChunks(doc.bufferedObservationChunks);
-      if (persistedChunks.length === 0) {
-        return { ok: true, result: EMPTY_SWAP_RESULT };
-      }
-      const chunks = Array.isArray(request.bufferedChunks) ? request.bufferedChunks : persistedChunks;
-      if (chunks.length === 0) {
-        return { ok: true, result: EMPTY_SWAP_RESULT };
-      }
-      const chunksToActivate = selectActivationBoundary(chunks, {
-        activationRatio: request.activationRatio,
-        messageTokensThreshold: request.messageTokensThreshold,
-        currentPendingTokens: request.currentPendingTokens,
-        forceMaxActivation: request.forceMaxActivation
-      });
-      const activatedChunks = chunks.slice(0, chunksToActivate);
-      const remainingChunks = chunks.slice(chunksToActivate);
-      const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
-      const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
-      const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
-      const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + (c.messageIds?.length ?? 0), 0);
-      const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
-      const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
-      const latestChunk = activatedChunks[activatedChunks.length - 1];
-      const lastObservedAt = request.lastObservedAt ?? latestChunk?.lastObservedAt ?? request.now;
-      const existingActive = doc.activeObservations || "";
-      const boundary = `
-
---- message boundary (${lastObservedAt}) ---
-
-`;
-      const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
-      await ctx.db.patch(doc._id, {
-        activeObservations: newActive,
-        observationTokenCount: Number(doc.observationTokenCount || 0) + activatedTokens,
-        // Decrement pending message tokens (clamped to zero)
-        pendingMessageTokens: Math.max(0, Number(doc.pendingMessageTokens || 0) - activatedMessageTokens),
-        bufferedObservationChunks: remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
-        lastObservedAt,
-        updatedAt: request.now
-      });
-      const latestChunkHints = activatedChunks[activatedChunks.length - 1];
-      return {
-        ok: true,
-        result: {
-          chunksActivated: activatedChunks.length,
-          messageTokensActivated: activatedMessageTokens,
-          observationTokensActivated: activatedTokens,
-          messagesActivated: activatedMessageCount,
-          activatedCycleIds,
-          activatedMessageIds,
-          observations: activatedContent,
-          perChunk: activatedChunks.map((c) => ({
-            cycleId: c.cycleId ?? "",
-            messageTokens: c.messageTokens ?? 0,
-            observationTokens: c.tokenCount,
-            messageCount: c.messageIds?.length ?? 0,
-            observations: c.observations
-          })),
-          suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
-          currentTask: latestChunkHints?.currentTask ?? void 0
-        }
-      };
-    }
-    case "omUpdateBufferedReflection": {
-      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
-      const existingContent = doc.bufferedReflection || "";
-      await ctx.db.patch(doc._id, {
-        bufferedReflection: existingContent ? `${existingContent}
-
-${request.reflection}` : request.reflection,
-        bufferedReflectionTokens: Number(doc.bufferedReflectionTokens || 0) + request.tokenCount,
-        bufferedReflectionInputTokens: Number(doc.bufferedReflectionInputTokens || 0) + request.inputTokenCount,
-        reflectedObservationLineCount: request.reflectedObservationLineCount,
-        updatedAt: request.updatedAt
-      });
-      return { ok: true };
-    }
-    case "omSwapBufferedReflection": {
-      const { currentRecord, newId, tokenCount, now } = request;
-      const doc = requireRecord(await findRecordById(ctx, convexTable, currentRecord.id), currentRecord.id);
-      const bufferedReflection = doc.bufferedReflection || "";
-      if (!bufferedReflection) {
-        throw new Error("No buffered reflection to swap");
-      }
-      const newObservations = mergeReflectionWithUnreflected(
-        doc.activeObservations || "",
-        bufferedReflection,
-        Number(doc.reflectedObservationLineCount || 0)
-      );
-      const newRecord = {
-        id: newId,
-        lookupKey: currentRecord.lookupKey,
-        scope: currentRecord.scope,
-        resourceId: currentRecord.resourceId,
-        threadId: currentRecord.threadId,
-        activeObservations: newObservations,
-        activeObservationsPendingUpdate: null,
-        originType: "reflection",
-        config: currentRecord.config,
-        generationCount: currentRecord.generationCount + 1,
-        lastObservedAt: currentRecord.lastObservedAt,
-        lastReflectionAt: now,
-        pendingMessageTokens: 0,
-        totalTokensObserved: currentRecord.totalTokensObserved,
-        observationTokenCount: tokenCount,
-        isObserving: false,
-        isReflecting: false,
-        isBufferingObservation: false,
-        isBufferingReflection: false,
-        lastBufferedAtTokens: 0,
-        lastBufferedAtTime: null,
-        observedTimezone: currentRecord.observedTimezone,
-        metadata: currentRecord.metadata,
-        createdAt: now,
-        updatedAt: now
-      };
-      await ctx.db.insert(convexTable, newRecord);
-      await ctx.db.patch(doc._id, {
-        bufferedReflection: null,
-        bufferedReflectionTokens: null,
-        bufferedReflectionInputTokens: null,
-        reflectedObservationLineCount: null,
-        updatedAt: now
-      });
-      return { ok: true, result: newRecord };
-    }
-    case "omUpdateConfig": {
-      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
-      const existing = parseJsonObject(doc.config);
-      const incoming = parseJsonObject(request.config);
-      const merged = deepMergeOMConfig(existing, incoming);
-      await ctx.db.patch(doc._id, {
-        config: JSON.stringify(merged),
-        updatedAt: request.updatedAt
-      });
-      return { ok: true };
-    }
-  }
-}
-
-// src/server/workflow-snapshot.ts
-var PENDING_MARKER_KEY = "__mastra_pending__";
-function isPendingMarker(val) {
-  return val !== null && typeof val === "object" && Object.prototype.hasOwnProperty.call(val, PENDING_MARKER_KEY) && val[PENDING_MARKER_KEY] === true && Object.keys(val).length === 1;
-}
-function isSuspendedStepResult(val) {
-  const result = val;
-  return val !== null && typeof val === "object" && "status" in val && result?.status === "suspended" && ("suspendPayload" in val || "suspendedAt" in val);
-}
-function canResetWithPendingMarker(val) {
-  if (val == null || isPendingMarker(val)) {
-    return true;
-  }
-  return isSuspendedStepResult(val);
-}
-function createEmptyWorkflowSnapshot(runId) {
-  return {
-    context: {},
-    activePaths: [],
-    activeStepsPath: {},
-    timestamp: Date.now(),
-    suspendedPaths: {},
-    resumeLabels: {},
-    serializedStepGraph: [],
-    value: {},
-    waitingPaths: {},
-    status: "pending",
-    runId
-  };
-}
-function mergeWorkflowStepResult({
-  snapshot,
-  stepId,
-  result,
-  requestContext
-}) {
-  if (!snapshot?.context) {
-    throw new Error(`Snapshot context not found for runId ${snapshot?.runId}`);
-  }
-  const existingResult = snapshot.context[stepId];
-  if (existingResult && "output" in existingResult && Array.isArray(existingResult.output) && result && typeof result === "object" && "output" in result && Array.isArray(result.output)) {
-    const existingOutput = existingResult.output;
-    const newOutput = result.output;
-    const mergedOutput = [...existingOutput];
-    const hasPendingMarker = newOutput.some(isPendingMarker);
-    for (let i = 0; i < Math.max(existingOutput.length, newOutput.length); i++) {
-      if (i < newOutput.length) {
-        const newVal = newOutput[i];
-        if (isPendingMarker(newVal)) {
-          if (i >= existingOutput.length || canResetWithPendingMarker(existingOutput[i])) {
-            mergedOutput[i] = null;
-          }
-        } else if (newVal !== null && newVal !== void 0 && !hasPendingMarker) {
-          mergedOutput[i] = newVal;
-        } else if (i >= existingOutput.length) {
-          mergedOutput[i] = null;
-        }
-      }
-    }
-    snapshot.context[stepId] = {
-      ...existingResult,
-      // Pending-marker writes are reset commands built from an earlier snapshot,
-      // so keep existing step-level fields and ignore sibling values they carry.
-      ...hasPendingMarker ? {} : result,
-      output: mergedOutput
-    };
-  } else {
-    snapshot.context[stepId] = result;
-  }
-  snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
-  return JSON.parse(JSON.stringify(snapshot.context));
-}
-
-// src/server/storage.ts
-var TABLE_VECTOR_INDEXES = "mastra_vector_indexes";
-var VECTOR_TABLE_PREFIX = "mastra_vector_";
-var CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
-var CONVEX_TABLE_BACKGROUND_TASKS = "mastra_background_tasks";
-var CONVEX_TABLE_DOCUMENTS = "mastra_documents";
-var CONVEX_TABLE_OBSERVATIONAL_MEMORY = "mastra_observational_memory";
-var STORAGE_MUTATION_BATCH_SIZE = 25;
-var LOAD_MANY_MAX_IDS_PER_REQUEST = 10;
-var DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
-var BACKGROUND_TASK_FIELD_ALIASES = {
-  tool_call_id: "toolCallId",
-  toolCallId: "tool_call_id",
-  tool_name: "toolName",
-  toolName: "tool_name",
-  agent_id: "agentId",
-  agentId: "agent_id",
-  run_id: "runId",
-  runId: "run_id",
-  thread_id: "threadId",
-  threadId: "thread_id",
-  resource_id: "resourceId",
-  resourceId: "resource_id",
-  suspend_payload: "suspendPayload",
-  suspendPayload: "suspend_payload",
-  retry_count: "retryCount",
-  retryCount: "retry_count",
-  max_retries: "maxRetries",
-  maxRetries: "max_retries",
-  timeout_ms: "timeoutMs",
-  timeoutMs: "timeout_ms"
-};
-function normalizeScheduleQueryLimit(limit) {
-  if (limit == null || !Number.isFinite(limit)) return DEFAULT_SCHEDULE_QUERY_LIMIT;
-  return Math.max(0, Math.floor(limit));
-}
-function normalizeLoadManyIds(ids) {
-  if (ids.length > LOAD_MANY_MAX_IDS_PER_REQUEST) {
-    throw new Error(`loadMany supports at most ${LOAD_MANY_MAX_IDS_PER_REQUEST} ids per request`);
-  }
-  return [...new Set(ids)];
-}
-function applyConvexEqualityFilters(query, filters, indexedFields = /* @__PURE__ */ new Set()) {
-  const remainingFilters = filters?.filter((filter) => !indexedFields.has(filter.field));
-  if (!remainingFilters?.length) return query;
-  return query.filter((q) => {
-    const predicates = remainingFilters.map((filter) => q.eq(q.field(filter.field), filter.value));
-    return predicates.length === 1 ? predicates[0] : q.and(...predicates);
-  });
-}
-async function mapInBatches(inputs, batchSize, mapper) {
-  const results = [];
-  for (let index = 0; index < inputs.length; index += batchSize) {
-    results.push(...await Promise.all(inputs.slice(index, index + batchSize).map(mapper)));
-  }
-  return results;
-}
-async function deleteDocs(ctx, docs) {
-  await mapInBatches(docs, STORAGE_MUTATION_BATCH_SIZE, (doc) => ctx.db.delete(doc._id));
-}
-async function findExistingDocsByIds(ids, findDoc) {
-  const docs = await mapInBatches([...new Set(ids)], STORAGE_MUTATION_BATCH_SIZE, findDoc);
-  return docs.filter((doc) => Boolean(doc));
-}
-function isBackgroundTasksTable(convexTable, request) {
-  return convexTable === CONVEX_TABLE_BACKGROUND_TASKS && request.tableName === constants.TABLE_BACKGROUND_TASKS;
-}
-function matchesFilters(record, filters) {
-  return filters.every((filter) => {
-    if (record[filter.field] === filter.value) return true;
-    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[filter.field];
-    return alternateField ? record[alternateField] === filter.value : false;
-  });
-}
-function mergeLegacyRecord(record, patch) {
-  const merged = { ...record };
-  for (const [field, value] of Object.entries(patch)) {
-    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[field];
-    if (alternateField) delete merged[alternateField];
-    merged[field] = value;
-  }
-  return merged;
-}
-function stripPatchKeys(record, keys) {
-  const stripped = { ...record };
-  for (const key of keys) delete stripped[key];
-  return stripped;
-}
-function dedupeByRecordId(records) {
-  const seen = /* @__PURE__ */ new Set();
-  return records.filter((record) => {
-    if (record?.id == null) return true;
-    const id = String(record.id);
-    if (seen.has(id)) return false;
-    seen.add(id);
-    return true;
-  });
-}
-function isMissingBackgroundTaskSchemaError(error) {
-  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-  return message.includes(CONVEX_TABLE_BACKGROUND_TASKS) && (message.includes("does not exist") || message.includes("not found") || message.includes("not defined") || message.includes("no such"));
-}
-async function findGenericDocumentById(ctx, tableName, id) {
-  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique();
-}
-async function findGenericDocumentsByTable(ctx, tableName, limit) {
-  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table", (q) => q.eq("table", tableName)).take(limit);
-}
-async function filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords) {
-  const records = await mapInBatches(legacyRecords, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
-    if (record.id == null) return record;
-    const typedDoc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", String(record.id))).unique();
-    return typedDoc ? null : record;
-  });
-  return records.filter((record) => Boolean(record));
-}
-function coalesceTypedRecordsForBatchInsert(records) {
-  const recordsById = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const id = record.id;
-    if (!id) continue;
-    const key = String(id);
-    recordsById.set(key, { ...recordsById.get(key) ?? {}, ...record });
-  }
-  return [...recordsById.values()];
-}
-function coalesceLastRecordById(records) {
-  const recordsById = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const id = record.id;
-    if (!id) continue;
-    recordsById.set(String(id), record);
-  }
-  return [...recordsById.values()];
-}
-function resolveTable(tableName) {
-  switch (tableName) {
-    case constants.TABLE_THREADS:
-      return { convexTable: "mastra_threads", isTyped: true };
-    case constants.TABLE_MESSAGES:
-      return { convexTable: "mastra_messages", isTyped: true };
-    case constants.TABLE_RESOURCES:
-      return { convexTable: "mastra_resources", isTyped: true };
-    case constants.TABLE_WORKFLOW_SNAPSHOT:
-      return { convexTable: CONVEX_TABLE_WORKFLOW_SNAPSHOTS, isTyped: true };
-    case constants.TABLE_SCORERS:
-      return { convexTable: "mastra_scorers", isTyped: true };
-    case constants.TABLE_SCHEDULES:
-      return { convexTable: "mastra_schedules", isTyped: true };
-    case constants.TABLE_SCHEDULE_TRIGGERS:
-      return { convexTable: "mastra_schedule_triggers", isTyped: true };
-    case constants.TABLE_CHANNEL_INSTALLATIONS:
-      return { convexTable: "mastra_channel_installations", isTyped: true };
-    case constants.TABLE_CHANNEL_CONFIG:
-      return { convexTable: "mastra_channel_config", isTyped: true };
-    case constants.TABLE_BACKGROUND_TASKS:
-      return { convexTable: CONVEX_TABLE_BACKGROUND_TASKS, isTyped: true };
-    case TABLE_VECTOR_INDEXES:
-      return { convexTable: "mastra_vector_indexes", isTyped: true };
-    case CONVEX_TABLE_OBSERVATIONAL_MEMORY:
-      return { convexTable: CONVEX_TABLE_OBSERVATIONAL_MEMORY, isTyped: true };
-    default:
-      if (tableName.startsWith(VECTOR_TABLE_PREFIX)) {
-        return { convexTable: "mastra_vectors", isTyped: true };
-      }
-      return { convexTable: "mastra_documents", isTyped: false };
-  }
-}
-var mastraStorage = server.mutationGeneric(async (ctx, request) => {
-  try {
-    const { convexTable, isTyped } = resolveTable(request.tableName);
-    if (request.tableName.startsWith(VECTOR_TABLE_PREFIX) && request.tableName !== TABLE_VECTOR_INDEXES) {
-      return await handleVectorOperation(ctx, request);
-    }
-    if (isTyped) {
-      if (isBackgroundTasksTable(convexTable, request)) {
-        try {
-          return await handleTypedOperation(ctx, convexTable, request);
-        } catch (error) {
-          if (!isMissingBackgroundTaskSchemaError(error)) throw error;
-          return handleGenericOperation(ctx, request);
-        }
-      }
-      return handleTypedOperation(ctx, convexTable, request);
-    }
-    return handleGenericOperation(ctx, request);
-  } catch (error) {
-    const err = error;
-    return {
-      ok: false,
-      error: err.message
-    };
-  }
-});
-function parseStoredSnapshot(stored, runId) {
-  if (typeof stored === "string") return JSON.parse(stored);
-  return JSON.parse(JSON.stringify(stored ?? createEmptyWorkflowSnapshot(runId)));
-}
-function parseMetadataForMerge(metadata) {
-  if (metadata == null) return {};
-  if (typeof metadata === "string") {
-    try {
-      const parsed = JSON.parse(metadata);
-      return parseMetadataForMerge(parsed);
-    } catch {
-      return {};
-    }
-  }
-  if (typeof metadata === "object" && !Array.isArray(metadata)) {
-    return metadata;
-  }
-  return {};
-}
-function mergeMetadata(existing, update) {
-  return {
-    ...parseMetadataForMerge(existing),
-    ...update ?? {}
-  };
-}
-async function handleTypedOperation(ctx, convexTable, request) {
-  switch (request.op) {
-    case "omGetLatest":
-    case "omGetHistory":
-    case "omUpdateActive":
-    case "omAppendBufferedChunk":
-    case "omSwapBuffered":
-    case "omUpdateBufferedReflection":
-    case "omSwapBufferedReflection":
-    case "omUpdateConfig": {
-      if (convexTable !== CONVEX_TABLE_OBSERVATIONAL_MEMORY) {
-        throw new Error(`${request.op} is only supported for ${CONVEX_TABLE_OBSERVATIONAL_MEMORY}`);
-      }
-      return handleObservationalMemoryOperation(ctx, convexTable, request);
-    }
-    case "createSchedule": {
-      if (convexTable !== "mastra_schedules") {
-        throw new Error(`createSchedule is only supported for mastra_schedules`);
-      }
-      const record = request.record;
-      const id = record.id;
-      if (!id) {
-        throw new Error(`Schedule is missing an id`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
-      if (existing) {
-        throw new Error(`Schedule with id "${id}" already exists`);
-      }
-      await ctx.db.insert(convexTable, record);
-      return { ok: true };
-    }
-    case "recordScheduleTrigger": {
-      if (convexTable !== "mastra_schedule_triggers") {
-        throw new Error(`recordScheduleTrigger is only supported for mastra_schedule_triggers`);
-      }
-      const record = request.record;
-      const id = record.id;
-      if (!id) {
-        throw new Error(`Schedule trigger is missing an id`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
-      if (existing) {
-        throw new Error(`Schedule trigger with id "${id}" already exists`);
-      }
-      await ctx.db.insert(convexTable, record);
-      return { ok: true };
-    }
-    case "listDueSchedules": {
-      if (convexTable !== "mastra_schedules") {
-        throw new Error(`listDueSchedules is only supported for mastra_schedules`);
-      }
-      const query = ctx.db.query(convexTable).withIndex("by_status_next_fire_at", (q) => q.eq("status", "active").lte("next_fire_at", request.now));
-      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
-      return { ok: true, result: docs };
-    }
-    case "updateScheduleNextFire": {
-      if (convexTable !== "mastra_schedules") {
-        throw new Error(`updateScheduleNextFire is only supported for mastra_schedules`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
-      if (!existing || existing.status !== "active" || existing.next_fire_at !== request.expectedNextFireAt) {
-        return { ok: true, result: false };
-      }
-      await ctx.db.patch(existing._id, {
-        next_fire_at: request.newNextFireAt,
-        last_fire_at: request.lastFireAt,
-        last_run_id: request.lastRunId,
-        updated_at: Date.now()
-      });
-      return { ok: true, result: true };
-    }
-    case "updateSchedule": {
-      if (convexTable !== "mastra_schedules") {
-        throw new Error(`updateSchedule is only supported for mastra_schedules`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
-      if (!existing) {
-        throw new Error(`Schedule ${request.id} not found`);
-      }
-      await ctx.db.patch(existing._id, request.patch);
-      return { ok: true, result: { ...existing, ...request.patch } };
-    }
-    case "listScheduleTriggers": {
-      if (convexTable !== "mastra_schedule_triggers") {
-        throw new Error(`listScheduleTriggers is only supported for mastra_schedule_triggers`);
-      }
-      const query = ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => {
-        let builder = q.eq("schedule_id", request.scheduleId);
-        if (request.fromActualFireAt != null) {
-          builder = builder.gte("actual_fire_at", request.fromActualFireAt);
-        }
-        if (request.toActualFireAt != null) {
-          builder = builder.lt("actual_fire_at", request.toActualFireAt);
-        }
-        return builder;
-      }).order("desc");
-      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
-      return { ok: true, result: docs };
-    }
-    case "deleteScheduleTriggers": {
-      if (convexTable !== "mastra_schedule_triggers") {
-        throw new Error(`deleteScheduleTriggers is only supported for mastra_schedule_triggers`);
-      }
-      const docs = await ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => q.eq("schedule_id", request.scheduleId)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
-      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
-      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore };
-    }
-    case "insert": {
-      const record = request.record;
-      const id = record.id;
-      if (!id) {
-        throw new Error(`Record is missing an id`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
-      if (existing) {
-        const { id: _, ...updateData } = record;
-        await ctx.db.patch(existing._id, updateData);
-      } else {
-        await ctx.db.insert(convexTable, record);
-      }
-      return { ok: true };
-    }
-    case "batchInsert": {
-      const records = coalesceTypedRecordsForBatchInsert(request.records);
-      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
-        const id = record.id;
-        const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
-        if (existing) {
-          const { id: _, ...updateData } = record;
-          await ctx.db.patch(existing._id, updateData);
-        } else {
-          await ctx.db.insert(convexTable, record);
-        }
-      });
-      return { ok: true };
-    }
-    case "updateThread": {
-      if (convexTable !== "mastra_threads") {
-        return { ok: false, error: `Unsupported operation ${request.op} for table ${request.tableName}` };
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
-      if (!existing) {
-        return { ok: true, result: null };
-      }
-      const patchRecord = {
-        title: request.title,
-        metadata: mergeMetadata(existing.metadata, request.metadata),
-        updatedAt: request.updatedAt
-      };
-      await ctx.db.patch(existing._id, patchRecord);
-      return { ok: true, result: { ...existing, ...patchRecord } };
-    }
-    case "updateResource": {
-      if (convexTable !== "mastra_resources") {
-        return { ok: false, error: `Unsupported operation ${request.op} for table ${request.tableName}` };
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.resourceId)).unique();
-      if (!existing) {
-        const record = {
-          id: request.resourceId,
-          ...request.workingMemory !== void 0 ? { workingMemory: request.workingMemory } : {},
-          metadata: request.metadata ?? {},
-          createdAt: request.createdAt,
-          updatedAt: request.updatedAt
-        };
-        await ctx.db.insert(convexTable, record);
-        return { ok: true, result: record };
-      }
-      const patchRecord = {
-        updatedAt: request.updatedAt
-      };
-      if (request.workingMemory !== void 0) {
-        patchRecord.workingMemory = request.workingMemory;
-      }
-      if (request.metadata !== void 0) {
-        patchRecord.metadata = mergeMetadata(existing.metadata, request.metadata);
-      }
-      await ctx.db.patch(existing._id, patchRecord);
-      return { ok: true, result: { ...existing, ...patchRecord } };
-    }
-    case "patch": {
-      const patchRecord = stripPatchKeys(request.record, ["id"]);
-      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
-      if (!existing) {
-        if (isBackgroundTasksTable(convexTable, request)) {
-          const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
-          if (legacy) {
-            await ctx.db.patch(legacy._id, { record: mergeLegacyRecord(legacy.record, patchRecord) });
-            return { ok: true, result: true };
-          }
-        }
-        return { ok: true, result: false };
-      }
-      await ctx.db.patch(existing._id, patchRecord);
-      if (isBackgroundTasksTable(convexTable, request)) {
-        const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
-        if (legacy) {
-          await ctx.db.delete(legacy._id);
-        }
-      }
-      return { ok: true, result: true };
-    }
-    case "load": {
-      const keys = request.keys;
-      if (keys.id) {
-        const doc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", keys.id)).unique();
-        if (!doc && isBackgroundTasksTable(convexTable, request)) {
-          const legacy = await findGenericDocumentById(ctx, request.tableName, String(keys.id));
-          return { ok: true, result: legacy?.record ?? null };
-        }
-        return { ok: true, result: doc || null };
-      }
-      if (convexTable === CONVEX_TABLE_WORKFLOW_SNAPSHOTS && typeof keys.workflow_name === "string" && typeof keys.run_id === "string") {
-        const doc = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", keys.workflow_name).eq("run_id", keys.run_id)).unique();
-        return { ok: true, result: doc || null };
-      }
-      const docs = await ctx.db.query(convexTable).take(1e4);
-      const match = docs.find((doc) => Object.entries(keys).every(([key, value]) => doc[key] === value));
-      return { ok: true, result: match || null };
-    }
-    case "loadMany": {
-      const ids = normalizeLoadManyIds(request.ids);
-      const docs = await mapInBatches(
-        ids,
-        STORAGE_MUTATION_BATCH_SIZE,
-        (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()
-      );
-      const typedDocs = docs.filter(Boolean);
-      if (!isBackgroundTasksTable(convexTable, request)) {
-        return { ok: true, result: typedDocs };
-      }
-      const typedDocsById = new Map(typedDocs.map((doc) => [String(doc.id), doc]));
-      const legacyDocs = await mapInBatches(
-        ids.filter((id) => !typedDocsById.has(id)),
-        STORAGE_MUTATION_BATCH_SIZE,
-        (id) => findGenericDocumentById(ctx, request.tableName, id)
-      );
-      const legacyRecordsById = new Map(
-        legacyDocs.filter((doc) => Boolean(doc)).map((doc) => [String(doc.record.id), doc.record])
-      );
-      return {
-        ok: true,
-        result: ids.map((id) => typedDocsById.get(id) ?? legacyRecordsById.get(id)).filter(Boolean)
-      };
-    }
-    case "queryTable": {
-      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
-      let query;
-      let indexedFields = /* @__PURE__ */ new Set();
-      if (request.indexHint) {
-        const hint = request.indexHint;
-        if (hint.index === "by_workflow") {
-          query = ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName));
-        } else if (hint.index === "by_workflow_run") {
-          query = ctx.db.query(convexTable).withIndex(
-            "by_workflow_run",
-            (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId)
-          );
-        } else {
-          query = ctx.db.query(convexTable);
-        }
-      } else if (request.filters && request.filters.length > 0) {
-        const match = findBestIndex(convexTable, request.filters);
-        if (match) {
-          query = ctx.db.query(convexTable).withIndex(match.indexName, (q) => {
-            let builder = q;
-            for (const filter of match.indexedFilters) {
-              builder = builder.eq(filter.field, filter.value);
-            }
-            return builder;
-          });
-          indexedFields = new Set(match.indexedFilters.map((filter) => filter.field));
-        } else {
-          query = ctx.db.query(convexTable);
-        }
-      } else {
-        query = ctx.db.query(convexTable);
-      }
-      let docs = await applyConvexEqualityFilters(query, request.filters, indexedFields).take(maxDocs);
-      if (isBackgroundTasksTable(convexTable, request)) {
-        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, maxDocs);
-        let legacyRecords = legacyDocs.map((doc) => doc.record);
-        if (request.filters && request.filters.length > 0) {
-          legacyRecords = legacyRecords.filter((record) => matchesFilters(record, request.filters));
-        }
-        legacyRecords = await filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords);
-        docs.push(...legacyRecords);
-        docs = dedupeByRecordId(docs);
-      }
-      if (request.limit) {
-        docs = docs.slice(0, request.limit);
-      }
-      return { ok: true, result: docs };
-    }
-    case "clearTable":
-    case "dropTable": {
-      const docs = await ctx.db.query(convexTable).take(STORAGE_MUTATION_BATCH_SIZE + 1);
-      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
-      let docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
-      let legacyHasMore = false;
-      if (!hasMore && docsToDelete.length < STORAGE_MUTATION_BATCH_SIZE && isBackgroundTasksTable(convexTable, request)) {
-        const remainingBatchSize = STORAGE_MUTATION_BATCH_SIZE - docsToDelete.length;
-        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, remainingBatchSize + 1);
-        legacyHasMore = legacyDocs.length > remainingBatchSize;
-        docsToDelete = docsToDelete.concat(legacyHasMore ? legacyDocs.slice(0, remainingBatchSize) : legacyDocs);
-      }
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore: hasMore || legacyHasMore };
-    }
-    case "deleteMany": {
-      const docsToDelete = await findExistingDocsByIds(
-        request.ids,
-        (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()
-      );
-      if (isBackgroundTasksTable(convexTable, request)) {
-        docsToDelete.push(
-          ...await findExistingDocsByIds(request.ids, (id) => findGenericDocumentById(ctx, request.tableName, id))
-        );
-      }
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true };
-    }
-    case "mergeWorkflowStepResult": {
-      if (convexTable !== CONVEX_TABLE_WORKFLOW_SNAPSHOTS) {
-        return { ok: false, error: `Unsupported operation ${request.op} for table ${request.tableName}` };
-      }
-      const existing = await ctx.db.query(convexTable).withIndex(
-        "by_workflow_run",
-        (q) => q.eq("workflow_name", request.workflowName).eq("run_id", request.runId)
-      ).unique();
-      if (!existing) {
-        return { ok: false, error: `Workflow snapshot not found for runId ${request.runId}` };
-      }
-      const snapshot = parseStoredSnapshot(existing.snapshot, request.runId);
-      if (!snapshot.context) {
-        return { ok: false, error: `Snapshot for runId ${request.runId} is missing or has invalid context` };
-      }
-      const context = mergeWorkflowStepResult({
-        snapshot,
-        stepId: request.stepId,
-        result: JSON.parse(request.result),
-        requestContext: JSON.parse(request.requestContext)
-      });
-      await ctx.db.patch(existing._id, {
-        snapshot: JSON.stringify(snapshot),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return { ok: true, result: JSON.stringify(context) };
-    }
-    case "mergeWorkflowState": {
-      if (convexTable !== CONVEX_TABLE_WORKFLOW_SNAPSHOTS) {
-        return { ok: false, error: `Unsupported operation ${request.op} for table ${request.tableName}` };
-      }
-      const existing = await ctx.db.query(convexTable).withIndex(
-        "by_workflow_run",
-        (q) => q.eq("workflow_name", request.workflowName).eq("run_id", request.runId)
-      ).unique();
-      if (!existing) {
-        return { ok: false, error: `Workflow snapshot not found for runId ${request.runId}` };
-      }
-      const snapshot = parseStoredSnapshot(existing.snapshot, request.runId);
-      if (!snapshot.context) {
-        return { ok: false, error: `Snapshot for runId ${request.runId} is missing or has invalid context` };
-      }
-      const mergedSnapshot = { ...snapshot, ...JSON.parse(request.opts) };
-      await ctx.db.patch(existing._id, {
-        snapshot: JSON.stringify(mergedSnapshot),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return { ok: true, result: JSON.stringify(mergedSnapshot) };
-    }
-    default:
-      return { ok: false, error: `Unsupported operation ${request.op}` };
-  }
-}
-async function handleVectorOperation(ctx, request) {
-  const indexName = request.tableName.replace(VECTOR_TABLE_PREFIX, "");
-  const convexTable = "mastra_vectors";
-  switch (request.op) {
-    case "insert": {
-      const record = request.record;
-      const id = record.id;
-      if (!id) {
-        throw new Error(`Vector record is missing an id`);
-      }
-      const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
-      if (existing) {
-        await ctx.db.patch(existing._id, {
-          embedding: record.embedding,
-          metadata: record.metadata
-        });
-      } else {
-        await ctx.db.insert(convexTable, {
-          id,
-          indexName,
-          embedding: record.embedding,
-          metadata: record.metadata
-        });
-      }
-      return { ok: true };
-    }
-    case "batchInsert": {
-      const records = coalesceLastRecordById(request.records);
-      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
-        const id = record.id;
-        const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
-        if (existing) {
-          await ctx.db.patch(existing._id, {
-            embedding: record.embedding,
-            metadata: record.metadata
-          });
-        } else {
-          await ctx.db.insert(convexTable, {
-            id,
-            indexName,
-            embedding: record.embedding,
-            metadata: record.metadata
-          });
-        }
-      });
-      return { ok: true };
-    }
-    case "patch": {
-      const patchRecord = stripPatchKeys(request.record, ["id", "indexName"]);
-      const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", request.id)).unique();
-      if (!existing) {
-        return { ok: true, result: false };
-      }
-      await ctx.db.patch(existing._id, patchRecord);
-      return { ok: true, result: true };
-    }
-    case "load": {
-      const keys = request.keys;
-      if (keys.id) {
-        const doc = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", keys.id)).unique();
-        return { ok: true, result: doc || null };
-      }
-      return { ok: true, result: null };
-    }
-    case "loadMany": {
-      const docs = await findExistingDocsByIds(
-        normalizeLoadManyIds(request.ids),
-        (id) => ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique()
-      );
-      return { ok: true, result: docs };
-    }
-    case "queryTable": {
-      if (request.cursor !== void 0 && request.pageSize === void 0) {
-        throw new Error("queryTable cursor requires pageSize");
-      }
-      if (request.pageSize !== void 0) {
-        if (!Number.isInteger(request.pageSize) || request.pageSize <= 0) {
-          throw new Error("queryTable pageSize must be a positive integer");
-        }
-        if (request.limit !== void 0) {
-          throw new Error("queryTable limit cannot be combined with pageSize");
-        }
-        const page = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).paginate({ cursor: request.cursor ?? null, numItems: request.pageSize });
-        let docs2 = page.page;
-        if (request.filters && request.filters.length > 0) {
-          docs2 = docs2.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
-        }
-        return {
-          ok: true,
-          result: docs2,
-          hasMore: !page.isDone,
-          continuationCursor: page.continueCursor
-        };
-      }
-      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
-      let docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(maxDocs);
-      if (request.filters && request.filters.length > 0) {
-        docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
-      }
-      if (request.limit) {
-        docs = docs.slice(0, request.limit);
-      }
-      return { ok: true, result: docs };
-    }
-    case "clearTable":
-    case "dropTable": {
-      const docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
-      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
-      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore };
-    }
-    case "deleteMany": {
-      const docsToDelete = await findExistingDocsByIds(
-        request.ids,
-        (id) => (
-          // Use composite key (indexName, id) to scope deletion per index
-          ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique()
-        )
-      );
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true };
-    }
-    default:
-      return { ok: false, error: `Unsupported operation ${request.op}` };
-  }
-}
-async function handleGenericOperation(ctx, request) {
-  const tableName = request.tableName;
-  const convexTable = "mastra_documents";
-  switch (request.op) {
-    case "insert": {
-      const record = request.record;
-      if (!record.id) {
-        throw new Error(`Record for table ${tableName} is missing an id`);
-      }
-      const primaryKey = String(record.id);
-      const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
-      if (existing) {
-        await ctx.db.patch(existing._id, { record });
-      } else {
-        await ctx.db.insert(convexTable, {
-          table: tableName,
-          primaryKey,
-          record
-        });
-      }
-      return { ok: true };
-    }
-    case "batchInsert": {
-      const records = coalesceLastRecordById(request.records);
-      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
-        const primaryKey = String(record.id);
-        const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
-        if (existing) {
-          await ctx.db.patch(existing._id, { record });
-        } else {
-          await ctx.db.insert(convexTable, {
-            table: tableName,
-            primaryKey,
-            record
-          });
-        }
-      });
-      return { ok: true };
-    }
-    case "patch": {
-      const patchRecord = stripPatchKeys(request.record, ["id"]);
-      const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(request.id))).unique();
-      if (!existing) {
-        return { ok: true, result: false };
-      }
-      await ctx.db.patch(existing._id, {
-        record: tableName === constants.TABLE_BACKGROUND_TASKS ? mergeLegacyRecord(existing.record, patchRecord) : { ...existing.record, ...patchRecord }
-      });
-      return { ok: true, result: true };
-    }
-    case "load": {
-      const keys = request.keys;
-      if (keys.id) {
-        const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(keys.id))).unique();
-        return { ok: true, result: existing ? existing.record : null };
-      }
-      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(1e4);
-      const match = docs.find((doc) => Object.entries(keys).every(([key, value]) => doc.record?.[key] === value));
-      return { ok: true, result: match ? match.record : null };
-    }
-    case "loadMany": {
-      const docs = await mapInBatches(
-        normalizeLoadManyIds(request.ids),
-        STORAGE_MUTATION_BATCH_SIZE,
-        (id) => findGenericDocumentById(ctx, tableName, id)
-      );
-      return {
-        ok: true,
-        result: docs.filter((doc) => Boolean(doc)).map((doc) => doc.record)
-      };
-    }
-    case "queryTable": {
-      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
-      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(maxDocs);
-      let records = docs.map((doc) => doc.record);
-      if (request.filters && request.filters.length > 0) {
-        records = records.filter(
-          (record) => tableName === constants.TABLE_BACKGROUND_TASKS ? matchesFilters(record, request.filters) : request.filters.every((filter) => record?.[filter.field] === filter.value)
-        );
-      }
-      if (request.limit) {
-        records = records.slice(0, request.limit);
-      }
-      return { ok: true, result: records };
-    }
-    case "clearTable":
-    case "dropTable": {
-      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
-      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
-      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore };
-    }
-    case "deleteMany": {
-      const docsToDelete = await findExistingDocsByIds(
-        request.ids,
-        (id) => ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique()
-      );
-      await deleteDocs(ctx, docsToDelete);
-      return { ok: true };
-    }
-    default:
-      return { ok: false, error: `Unsupported operation ${request.op}` };
-  }
-}
-var DEFAULT_ID_FIELD = "id";
-var DEFAULT_ID_INDEX = "by_record_id";
-var DEFAULT_VECTOR_FIELD = "embedding";
-var DEFAULT_METADATA_FIELD = "metadata";
-var NATIVE_VECTOR_BATCH_SIZE = 25;
-var MAX_CONVEX_VECTOR_RESULTS = 256;
-var nativeVectorFilterValueValidator = values.v.union(values.v.string(), values.v.number(), values.v.boolean(), values.v.null());
-var nativeVectorFilterClauseValidator = values.v.object({
-  field: values.v.string(),
-  value: nativeVectorFilterValueValidator
-});
-var nativeVectorFilterValidator = values.v.union(
-  nativeVectorFilterClauseValidator,
-  values.v.object({ $or: values.v.array(nativeVectorFilterClauseValidator) })
-);
-var nativeVectorIndexConfigValidator = values.v.object({
-  tableName: values.v.string(),
-  vectorIndexName: values.v.string(),
-  dimension: values.v.optional(values.v.number()),
-  idField: values.v.optional(values.v.string()),
-  idIndexName: values.v.optional(values.v.string()),
-  vectorField: values.v.optional(values.v.string()),
-  metadataField: values.v.optional(values.v.string()),
-  filterFields: values.v.optional(values.v.array(values.v.string()))
-});
-function idField(config) {
-  return config.idField ?? DEFAULT_ID_FIELD;
-}
-function idIndexName(config) {
-  return config.idIndexName ?? DEFAULT_ID_INDEX;
-}
-function vectorField(config) {
-  return config.vectorField ?? DEFAULT_VECTOR_FIELD;
-}
-function metadataField(config) {
-  return config.metadataField ?? DEFAULT_METADATA_FIELD;
-}
-function asTableName(tableName) {
-  return tableName;
-}
-function asConvexId(id) {
-  return id;
-}
-function pickFilterFields(metadata, filterFields) {
-  const fields = {};
-  if (!metadata || !filterFields) return fields;
-  for (const field of filterFields) {
-    const value = metadata[field];
-    if (value !== void 0) {
-      fields[field] = value;
-    }
-  }
-  return fields;
-}
-function isMetadataRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateMetadataArray(metadata, idsLength) {
-  if (metadata === void 0) return void 0;
-  if (!Array.isArray(metadata)) {
-    throw new Error("Native vector upsert: metadata must be an array matching ids when provided");
-  }
-  if (metadata.length !== idsLength) {
-    throw new Error(`Native vector upsert: metadata length (${metadata.length}) must match ids length (${idsLength})`);
-  }
-  if (!metadata.every(isMetadataRecord)) {
-    throw new Error("Native vector upsert: metadata entries must be objects when provided");
-  }
-  return metadata;
-}
-function validateMetadataRecord(metadata) {
-  if (metadata === void 0) return void 0;
-  if (!isMetadataRecord(metadata)) {
-    throw new Error("Native vector update: metadata must be an object when provided");
-  }
-  return metadata;
-}
-function clearMissingFilterFields(patch, metadata, filterFields) {
-  if (!filterFields) return;
-  for (const field of filterFields) {
-    if (metadata[field] === void 0) {
-      patch[field] = void 0;
-    }
-  }
-}
-function omitVectorField(doc, config) {
-  const { [vectorField(config)]: _, ...docWithoutVector } = doc;
-  return docWithoutVector;
-}
-function buildRecord({
-  config,
-  id,
-  vector,
-  metadata
-}) {
-  return {
-    [idField(config)]: id,
-    [vectorField(config)]: vector,
-    ...metadata !== void 0 ? { [metadataField(config)]: metadata } : {},
-    ...pickFilterFields(metadata, config.filterFields)
-  };
-}
-async function findByRecordId(ctx, config, id) {
-  return ctx.db.query(asTableName(config.tableName)).withIndex(idIndexName(config), (q) => q.eq(idField(config), id)).unique();
-}
-async function mapInBatches2(inputs, mapper) {
-  const results = [];
-  for (let index = 0; index < inputs.length; index += NATIVE_VECTOR_BATCH_SIZE) {
-    results.push(
-      ...await Promise.all(
-        inputs.slice(index, index + NATIVE_VECTOR_BATCH_SIZE).map((input, batchIndex) => mapper(input, index + batchIndex))
-      )
-    );
-  }
-  return results;
-}
-function buildVectorFilter(q, filter) {
-  if (!filter) return void 0;
-  if ("$or" in filter) {
-    return q.or(...filter.$or.map((clause) => q.eq(clause.field, clause.value)));
-  }
-  return q.eq(filter.field, filter.value);
-}
-var mastraNativeVectorAction = server.actionGeneric({
-  args: {
-    config: nativeVectorIndexConfigValidator,
-    vector: values.v.array(values.v.number()),
-    limit: values.v.optional(values.v.number()),
-    filter: values.v.optional(nativeVectorFilterValidator)
-  },
-  handler: async (ctx, args) => {
-    const config = args.config;
-    const limit = args.limit;
-    const filter = args.filter;
-    if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1 || limit > MAX_CONVEX_VECTOR_RESULTS)) {
-      throw new Error(`Native vector query: limit must be an integer between 1 and ${MAX_CONVEX_VECTOR_RESULTS}`);
-    }
-    const results = await ctx.vectorSearch(asTableName(config.tableName), config.vectorIndexName, {
-      vector: args.vector,
-      ...limit !== void 0 ? { limit } : {},
-      ...filter ? { filter: (q) => buildVectorFilter(q, filter) } : {}
-    });
-    return results.map((result) => ({
-      id: String(result._id),
-      score: result._score
-    }));
-  }
-});
-var mastraNativeVectorQuery = server.queryGeneric({
-  args: {
-    op: values.v.union(values.v.literal("getByConvexIds"), values.v.literal("describe"), values.v.literal("listByIds")),
-    config: nativeVectorIndexConfigValidator,
-    ids: values.v.optional(values.v.array(values.v.string())),
-    includeVector: values.v.optional(values.v.boolean()),
-    countLimit: values.v.optional(values.v.number())
-  },
-  handler: async (ctx, args) => {
-    const config = args.config;
-    switch (args.op) {
-      case "getByConvexIds": {
-        const ids = args.ids;
-        if (!ids) {
-          throw new Error("Native vector query: ids are required");
-        }
-        const includeVector = args.includeVector === true;
-        const docs = await mapInBatches2(ids, (id) => ctx.db.get(asConvexId(id)));
-        return docs.filter((doc) => Boolean(doc)).map((doc) => includeVector ? doc : omitVectorField(doc, config));
-      }
-      case "describe": {
-        const limit = Math.max(1, Math.min(args.countLimit ?? 1e4, 1e4));
-        const docs = await ctx.db.query(asTableName(config.tableName)).take(limit + 1);
-        return {
-          count: Math.min(docs.length, limit),
-          countIsLimited: docs.length > limit
-        };
-      }
-      case "listByIds": {
-        const ids = args.ids;
-        if (!ids) {
-          throw new Error("Native vector query: ids are required");
-        }
-        return mapInBatches2(ids, (id) => findByRecordId(ctx, config, id));
-      }
-      default:
-        throw new Error(`Unsupported native vector query operation: ${args.op}`);
-    }
-  }
-});
-var mastraNativeVectorMutation = server.mutationGeneric({
-  args: {
-    op: values.v.union(values.v.literal("upsert"), values.v.literal("updateById"), values.v.literal("deleteByIds")),
-    config: nativeVectorIndexConfigValidator,
-    ids: values.v.optional(values.v.array(values.v.string())),
-    vectors: values.v.optional(values.v.array(values.v.array(values.v.number()))),
-    metadata: values.v.optional(values.v.any()),
-    id: values.v.optional(values.v.string()),
-    vector: values.v.optional(values.v.array(values.v.number()))
-  },
-  handler: async (ctx, args) => {
-    const config = args.config;
-    switch (args.op) {
-      case "upsert": {
-        const ids = args.ids;
-        const vectors = args.vectors;
-        if (!ids || !vectors) {
-          throw new Error("Native vector upsert: ids and vectors are required");
-        }
-        if (vectors.length !== ids.length) {
-          throw new Error(
-            `Native vector upsert: vectors length (${vectors.length}) must match ids length (${ids.length})`
-          );
-        }
-        const metadata = validateMetadataArray(args.metadata, ids.length);
-        if (new Set(ids).size !== ids.length) {
-          throw new Error("Native vector upsert: ids must be unique");
-        }
-        await mapInBatches2(ids, async (id, index) => {
-          const record = buildRecord({
-            config,
-            id,
-            vector: vectors[index],
-            metadata: metadata?.[index]
-          });
-          const existing = await findByRecordId(ctx, config, id);
-          if (existing?._id) {
-            const { _id: _, _creationTime: __, ...patch } = record;
-            if (metadata?.[index] !== void 0) {
-              clearMissingFilterFields(patch, metadata[index], config.filterFields);
-            }
-            await ctx.db.patch(existing._id, patch);
-          } else {
-            await ctx.db.insert(asTableName(config.tableName), record);
-          }
-        });
-        return { ok: true };
-      }
-      case "updateById": {
-        if (!args.id) {
-          throw new Error("Native vector update: id is required");
-        }
-        const existing = await findByRecordId(ctx, config, args.id);
-        if (!existing?._id) return { ok: true };
-        const patch = {};
-        if (args.vector) patch[vectorField(config)] = args.vector;
-        const metadata = validateMetadataRecord(args.metadata);
-        if (metadata !== void 0) {
-          const existingMetadata = isMetadataRecord(existing[metadataField(config)]) ? existing[metadataField(config)] : {};
-          patch[metadataField(config)] = { ...existingMetadata, ...metadata };
-          Object.assign(patch, pickFilterFields(patch[metadataField(config)], config.filterFields));
-        }
-        if (Object.keys(patch).length > 0) {
-          await ctx.db.patch(existing._id, patch);
-        }
-        return { ok: true };
-      }
-      case "deleteByIds": {
-        const ids = args.ids;
-        if (!ids) {
-          throw new Error("Native vector deleteByIds: ids are required");
-        }
-        const docs = await mapInBatches2(ids, (id) => findByRecordId(ctx, config, id));
-        await mapInBatches2(
-          docs.filter((doc) => Boolean(doc?._id)),
-          (doc) => ctx.db.delete(doc._id)
-        );
-        return { ok: true };
-      }
-      default:
-        throw new Error(`Unsupported native vector mutation operation: ${args.op}`);
-    }
-  }
-});
-
-exports.mastraCache = mastraCache;
-exports.mastraNativeVectorAction = mastraNativeVectorAction;
-exports.mastraNativeVectorMutation = mastraNativeVectorMutation;
-exports.mastraNativeVectorQuery = mastraNativeVectorQuery;
-exports.mastraStorage = mastraStorage;
-//# sourceMappingURL=chunk-2KILIA33.cjs.map
-//# sourceMappingURL=chunk-2KILIA33.cjs.map