'use strict';

var chunkLFZO2LHV_cjs = require('./chunk-LFZO2LHV.cjs');
var chunkNOXRQV2G_cjs = require('./chunk-NOXRQV2G.cjs');
var chunkRVD3DGBZ_cjs = require('./chunk-RVD3DGBZ.cjs');
var chunkZ7LCIYK7_cjs = require('./chunk-Z7LCIYK7.cjs');
var chunkG54X6VE6_cjs = require('./chunk-G54X6VE6.cjs');
var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
var agent = require('@mastra/core/agent');
var utils = require('@mastra/core/utils');

// src/server/handlers/memory.ts
var memory_exports = {};
chunkO7I5CWRX_cjs.__export(memory_exports, {
  AWAIT_BUFFER_STATUS_ROUTE: () => AWAIT_BUFFER_STATUS_ROUTE,
  CLONE_THREAD_ROUTE: () => CLONE_THREAD_ROUTE,
  CREATE_THREAD_NETWORK_ROUTE: () => CREATE_THREAD_NETWORK_ROUTE,
  CREATE_THREAD_ROUTE: () => CREATE_THREAD_ROUTE,
  DELETE_MESSAGES_NETWORK_ROUTE: () => DELETE_MESSAGES_NETWORK_ROUTE,
  DELETE_MESSAGES_ROUTE: () => DELETE_MESSAGES_ROUTE,
  DELETE_THREAD_NETWORK_ROUTE: () => DELETE_THREAD_NETWORK_ROUTE,
  DELETE_THREAD_ROUTE: () => DELETE_THREAD_ROUTE,
  GET_MEMORY_CONFIG_ROUTE: () => GET_MEMORY_CONFIG_ROUTE,
  GET_MEMORY_STATUS_NETWORK_ROUTE: () => GET_MEMORY_STATUS_NETWORK_ROUTE,
  GET_MEMORY_STATUS_ROUTE: () => GET_MEMORY_STATUS_ROUTE,
  GET_OBSERVATIONAL_MEMORY_ROUTE: () => GET_OBSERVATIONAL_MEMORY_ROUTE,
  GET_THREAD_BY_ID_NETWORK_ROUTE: () => GET_THREAD_BY_ID_NETWORK_ROUTE,
  GET_THREAD_BY_ID_ROUTE: () => GET_THREAD_BY_ID_ROUTE,
  GET_WORKING_MEMORY_ROUTE: () => GET_WORKING_MEMORY_ROUTE,
  LIST_MESSAGES_NETWORK_ROUTE: () => LIST_MESSAGES_NETWORK_ROUTE,
  LIST_MESSAGES_ROUTE: () => LIST_MESSAGES_ROUTE,
  LIST_THREADS_NETWORK_ROUTE: () => LIST_THREADS_NETWORK_ROUTE,
  LIST_THREADS_ROUTE: () => LIST_THREADS_ROUTE,
  SAVE_MESSAGES_NETWORK_ROUTE: () => SAVE_MESSAGES_NETWORK_ROUTE,
  SAVE_MESSAGES_ROUTE: () => SAVE_MESSAGES_ROUTE,
  SEARCH_MEMORY_ROUTE: () => SEARCH_MEMORY_ROUTE,
  UPDATE_THREAD_NETWORK_ROUTE: () => UPDATE_THREAD_NETWORK_ROUTE,
  UPDATE_THREAD_ROUTE: () => UPDATE_THREAD_ROUTE,
  UPDATE_WORKING_MEMORY_ROUTE: () => UPDATE_WORKING_MEMORY_ROUTE,
  getTextContent: () => getTextContent
});
function hasFGAUser(requestContext) {
  const user = requestContext?.get("user");
  return !!user && typeof user === "object";
}
function shouldFilterThreadsWithFGA(mastra, requestContext) {
  return !!mastra.getServer?.()?.fga && hasFGAUser(requestContext);
}
async function filterAccessibleThreads({
  mastra,
  requestContext,
  threads
}) {
  const fgaProvider = mastra.getServer?.()?.fga;
  if (!fgaProvider || !hasFGAUser(requestContext) || threads.length === 0) {
    return threads;
  }
  return fgaProvider.filterAccessible(
    requestContext.get("user"),
    threads,
    "thread",
    chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_READ
  );
}
function paginateThreads({
  threads,
  page,
  perPage
}) {
  const effectivePage = page ?? 0;
  const effectivePerPage = perPage ?? 100;
  if (effectivePerPage === false) {
    return {
      threads,
      page: effectivePage,
      perPage: false,
      total: threads.length,
      hasMore: false
    };
  }
  const start = effectivePage * effectivePerPage;
  const pagedThreads = threads.slice(start, start + effectivePerPage);
  return {
    threads: pagedThreads,
    page: effectivePage,
    perPage: effectivePerPage,
    total: threads.length,
    hasMore: start + pagedThreads.length < threads.length
  };
}
async function enforceDeleteMessagesThreadAccess({
  mastra,
  requestContext,
  memoryStore,
  messageIds,
  effectiveResourceId
}) {
  const { messages } = await memoryStore.listMessagesById({ messageIds });
  const threadIds = [...new Set(messages.map((m) => m.threadId).filter(Boolean))];
  if (messages.some((message) => !message.threadId)) {
    throw new chunk64ITUOXI_cjs.HTTPException(403, { message: "Access denied: unable to verify message thread access" });
  }
  for (const threadId of threadIds) {
    const thread = await memoryStore.getThreadById({ threadId });
    if (!thread) {
      throw new chunk64ITUOXI_cjs.HTTPException(403, { message: "Access denied: unable to verify message thread access" });
    }
    await chunkRVD3DGBZ_cjs.enforceThreadAccess({
      mastra,
      requestContext,
      threadId,
      thread,
      effectiveResourceId,
      permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_DELETE
    });
  }
}
function getTextContent(message) {
  if (typeof message.content === "string") {
    return message.content;
  }
  if (message.content && typeof message.content === "object" && "parts" in message.content) {
    const textPart = message.content.parts.find((p) => p.type === "text");
    return textPart?.text || "";
  }
  return "";
}
async function getMemoryFromContext({
  mastra,
  agentId,
  requestContext,
  allowMissingAgent = false
}) {
  const logger = mastra.getLogger();
  let agent;
  if (agentId) {
    try {
      agent = mastra.getAgentById(agentId);
    } catch (error) {
      logger.debug("Error getting agent from mastra, searching agents for agent", error);
    }
  }
  if (agentId && !agent) {
    logger.debug("Agent not found in registered agents, trying stored agents", { agentId });
    try {
      const storedAgent = await mastra.getEditor()?.agent.getById(agentId) ?? null;
      if (storedAgent) {
        agent = storedAgent;
      }
    } catch (error) {
      logger.debug("Error getting stored agent", error);
    }
  }
  if (agentId && !agent) {
    logger.debug("Stored agent not found, searching sub-agents", { agentId });
    const agents = mastra.listAgents();
    if (Object.keys(agents || {}).length) {
      for (const [_, ag] of Object.entries(agents)) {
        try {
          const subAgents = await ag.listAgents({ requestContext });
          if (subAgents[agentId]) {
            agent = subAgents[agentId];
            break;
          }
        } catch (error) {
          logger.debug("Error getting agent from agent", error);
        }
      }
    }
    if (!agent) {
      if (allowMissingAgent) {
        logger.debug("Agent not found in any resolution tier, returning null for storage fallback", { agentId });
        return null;
      }
      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Agent not found" });
    }
  }
  if (agent) {
    return await agent?.getMemory({
      requestContext
    });
  }
}
function getStorageFromContext({ mastra }) {
  return mastra.getStorage();
}
function agentSupportsMemory(agent) {
  if (!agent) return true;
  const candidate = agent;
  if (typeof candidate.supportsMemory === "function" && !candidate.supportsMemory()) {
    return false;
  }
  if (typeof candidate.hasOwnMemory === "function" && !candidate.hasOwnMemory()) {
    return false;
  }
  return true;
}
async function getAgentFromContext({
  mastra,
  agentId,
  requestContext
}) {
  if (!agentId) return null;
  const logger = mastra.getLogger();
  let agent$1 = null;
  try {
    agent$1 = mastra.getAgentById(agentId);
  } catch (error) {
    logger.debug("Error getting agent from mastra", error);
  }
  if (!agent$1) {
    logger.debug("Agent not found in registered agents, trying stored agents", { agentId });
    try {
      const storedAgent = await mastra.getEditor()?.agent.getById(agentId) ?? null;
      if (storedAgent) {
        agent$1 = storedAgent;
      }
    } catch (error) {
      logger.debug("Error getting stored agent", error);
    }
  }
  if (!agent$1) {
    logger.debug("Stored agent not found, searching sub-agents", { agentId });
    const agents = mastra.listAgents();
    if (Object.keys(agents || {}).length) {
      for (const [_, ag] of Object.entries(agents)) {
        try {
          const nestedAgents = await ag.listAgents({ requestContext });
          const nestedAgent = nestedAgents[agentId];
          if (nestedAgent instanceof agent.Agent) {
            agent$1 = nestedAgent;
            break;
          }
        } catch (error) {
          logger.debug("Error getting agent from agent", error);
        }
      }
    }
  }
  return agent$1;
}
async function getOMConfigFromAgent(agent, requestContext) {
  try {
    if (typeof agent.resolveProcessorById !== "function") {
      return null;
    }
    const omProcessor = await agent.resolveProcessorById("observational-memory", requestContext);
    if (!omProcessor) {
      return null;
    }
    const hasResolvedConfig = typeof omProcessor.getResolvedConfig === "function";
    if (hasResolvedConfig) {
      const resolvedConfig = await omProcessor.getResolvedConfig(requestContext);
      return {
        enabled: true,
        scope: resolvedConfig.scope || "resource",
        shareTokenBudget: resolvedConfig.shareTokenBudget,
        messageTokens: resolvedConfig.observation?.messageTokens,
        observationTokens: resolvedConfig.reflection?.observationTokens,
        observationModel: resolvedConfig.observation?.model,
        reflectionModel: resolvedConfig.reflection?.model,
        observationModelRouting: resolvedConfig.observation?.routing,
        reflectionModelRouting: resolvedConfig.reflection?.routing
      };
    }
    const processorConfig = omProcessor.config || {};
    return {
      enabled: true,
      scope: processorConfig.scope || "resource",
      shareTokenBudget: processorConfig.shareTokenBudget,
      messageTokens: processorConfig.observation?.messageTokens,
      observationTokens: processorConfig.reflection?.observationTokens,
      observationModel: void 0,
      reflectionModel: void 0,
      observationModelRouting: void 0,
      reflectionModelRouting: void 0
    };
  } catch {
    return null;
  }
}
async function getOMStatus(memoryStorage, resourceId, threadId) {
  try {
    const record = await memoryStorage.getObservationalMemory(threadId ?? null, resourceId);
    if (!record) {
      return { hasRecord: false };
    }
    return {
      hasRecord: true,
      originType: record.originType,
      lastObservedAt: record.lastObservedAt ?? null,
      tokenCount: record.totalTokensObserved,
      observationTokenCount: record.observationTokenCount,
      isObserving: record.isObserving,
      isReflecting: record.isReflecting
    };
  } catch {
    return null;
  }
}
var GET_MEMORY_STATUS_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/status",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.getMemoryStatusQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.memoryStatusResponseSchema,
  summary: "Get memory status",
  description: "Returns the current status of the memory system including configuration and health information",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, threadId, requestContext }) => {
    try {
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      const isGateway = agent ? await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent) : false;
      if (agent && isGateway) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          let omStatus;
          if (resourceId && threadId) {
            try {
              const { record } = await gwClient.getObservationRecord(threadId, resourceId);
              if (record) {
                omStatus = {
                  enabled: true,
                  hasRecord: true,
                  originType: record.originType,
                  lastObservedAt: record.lastObservedAt ? new Date(record.lastObservedAt) : void 0,
                  tokenCount: record.totalTokensObserved,
                  observationTokenCount: record.observationTokenCount,
                  isObserving: record.isObserving,
                  isReflecting: record.isReflecting
                };
              } else {
                omStatus = { enabled: true, hasRecord: false };
              }
            } catch {
              omStatus = { enabled: true };
            }
          } else {
            omStatus = { enabled: true };
          }
          return { result: true, memoryType: "gateway", observationalMemory: omStatus };
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (memory) {
        let omStatus;
        if (agent) {
          const omConfig = await getOMConfigFromAgent(agent, requestContext);
          if (omConfig?.enabled && resourceId) {
            const omThreadId = omConfig.scope === "resource" ? void 0 : threadId;
            try {
              const memoryStore = await memory.storage.getStore("memory");
              if (memoryStore) {
                const status = await getOMStatus(memoryStore, resourceId, omThreadId);
                if (status) {
                  omStatus = {
                    enabled: true,
                    ...status,
                    // Convert null to undefined for schema compatibility
                    lastObservedAt: status.lastObservedAt ?? void 0
                  };
                } else {
                  omStatus = { enabled: true, hasRecord: false };
                }
              }
            } catch {
              omStatus = { enabled: true };
            }
          } else if (omConfig?.enabled) {
            omStatus = { enabled: true };
          }
        }
        return { result: true, memoryType: "local", observationalMemory: omStatus };
      }
      if (!agentSupportsMemory(agent)) {
        return { result: false };
      }
      const storage = getStorageFromContext({ mastra });
      if (storage) {
        return { result: true };
      }
      return { result: false };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting memory status");
    }
  }
});
var GET_MEMORY_CONFIG_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/config",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.getMemoryConfigQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.memoryConfigResponseSchema,
  summary: "Get memory configuration",
  description: "Returns the memory configuration for a specific agent or the system default",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, requestContext }) => {
    try {
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent) && chunkLFZO2LHV_cjs.getGatewayClient()) {
        return {
          memoryType: "gateway",
          config: {
            observationalMemory: {
              enabled: true,
              scope: "thread",
              messageTokens: 3e4,
              observationTokens: 4e4
            }
          }
        };
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (!memory) {
        return { config: null };
      }
      const config = memory.getMergedThreadConfig({});
      let omConfig;
      if (agent) {
        omConfig = await getOMConfigFromAgent(agent, requestContext) ?? { enabled: false };
      }
      return {
        config: {
          ...config,
          observationalMemory: omConfig
        }
      };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting memory configuration");
    }
  }
});
var GET_OBSERVATIONAL_MEMORY_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/observational-memory",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.getObservationalMemoryQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.getObservationalMemoryResponseSchema,
  summary: "Get observational memory data",
  description: "Returns the current observational memory record and optional history for a resource/thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, threadId, from, to, offset, limit, requestContext }) => {
    try {
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (!agent) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Agent not found" });
      }
      const historyLimit = limit ?? 5;
      const historyOptions = { from, to, offset };
      if (await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient && resourceId && threadId) {
          const [recordResult, historyResult] = await Promise.all([
            gwClient.getObservationRecord(threadId, resourceId),
            gwClient.getObservationHistory(threadId, { resourceId, limit: historyLimit, from, to, offset })
          ]);
          return {
            record: recordResult.record ? chunkLFZO2LHV_cjs.toLocalOMRecord(recordResult.record) : null,
            history: historyResult.records?.length > 0 ? historyResult.records.map(chunkLFZO2LHV_cjs.toLocalOMRecord) : void 0
          };
        }
        return { record: null, history: void 0 };
      }
      const omConfig = await getOMConfigFromAgent(agent, requestContext);
      if (!omConfig?.enabled) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Observational Memory is not enabled for this agent" });
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not configured for this agent" });
      }
      let memoryStore;
      try {
        memoryStore = await memory.storage.getStore("memory");
      } catch {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory storage is not initialized" });
      }
      if (!memoryStore) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory storage is not initialized" });
      }
      const effectiveResourceId = resourceId;
      if (!effectiveResourceId) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "resourceId is required for observational memory lookup" });
      }
      const omThreadId = omConfig.scope === "resource" ? null : threadId ?? null;
      const record = await memoryStore.getObservationalMemory(omThreadId, effectiveResourceId);
      const history = await memoryStore.getObservationalMemoryHistory(
        omThreadId,
        effectiveResourceId,
        historyLimit,
        historyOptions
      );
      return {
        record: record ?? null,
        history: history.length > 0 ? history : void 0
      };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting observational memory");
    }
  }
});
var AWAIT_BUFFER_STATUS_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/observational-memory/buffer-status",
  responseType: "json",
  bodySchema: chunkNOXRQV2G_cjs.awaitBufferStatusBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.awaitBufferStatusResponseSchema,
  summary: "Await observational memory buffering completion",
  description: "Blocks until any in-flight buffering operations complete for the given thread/resource, then returns the updated record",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, threadId, requestContext }) => {
    try {
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (!agent) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Agent not found" });
      }
      if (await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient && resourceId && threadId) {
          const maxWaitMs = 3e4;
          const pollIntervalMs = 1e3;
          const deadline = Date.now() + maxWaitMs;
          let record2 = null;
          while (Date.now() < deadline) {
            const result = await gwClient.getObservationRecord(threadId, resourceId);
            record2 = result.record ? chunkLFZO2LHV_cjs.toLocalOMRecord(result.record) : null;
            if (!record2 || !record2.isBufferingObservation && !record2.isBufferingReflection) {
              break;
            }
            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
          }
          return { record: record2 };
        }
        return { record: null };
      }
      const omConfig = await getOMConfigFromAgent(agent, requestContext);
      if (!omConfig?.enabled) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Observational Memory is not enabled for this agent" });
      }
      const omProcessor = await agent.resolveProcessorById("observational-memory", requestContext);
      if (!omProcessor || typeof omProcessor.waitForBuffering !== "function") {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Observational Memory processor not available" });
      }
      await omProcessor.waitForBuffering(threadId, resourceId);
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not configured for this agent" });
      }
      let memoryStore;
      try {
        memoryStore = await memory.storage.getStore("memory");
      } catch {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory storage is not initialized" });
      }
      if (!memoryStore) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory storage is not initialized" });
      }
      const effectiveResourceId = resourceId;
      if (!effectiveResourceId) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "resourceId is required" });
      }
      const omThreadId = omConfig.scope === "resource" ? null : threadId ?? null;
      const record = await memoryStore.getObservationalMemory(omThreadId, effectiveResourceId);
      return { record: record ?? null };
    } catch (error) {
      console.error("Error awaiting buffer status", error);
      return chunkZ7LCIYK7_cjs.handleError(error, "Error awaiting buffer status");
    }
  }
});
var LIST_THREADS_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/threads",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.listThreadsQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.listThreadsResponseSchema,
  summary: "List memory threads",
  description: "Returns a paginated list of conversation threads with optional filtering by resource ID and/or metadata",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, metadata, requestContext, page, perPage, orderBy }) => {
    try {
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      const isGateway = agent ? await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent) : false;
      if (agent && isGateway) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          if (shouldFilterThreadsWithFGA(mastra, requestContext)) {
            const initialResult = await gwClient.listThreads({
              resourceId: effectiveResourceId,
              limit: 1,
              offset: 0
            });
            const allThreads = initialResult.total > 0 ? (await gwClient.listThreads({
              resourceId: effectiveResourceId,
              limit: initialResult.total,
              offset: 0
            })).threads.map(chunkLFZO2LHV_cjs.toLocalThread) : [];
            const accessibleThreads = await filterAccessibleThreads({
              mastra,
              requestContext,
              threads: allThreads
            });
            return paginateThreads({
              threads: accessibleThreads,
              page,
              perPage
            });
          }
          const effectivePage = page ?? 0;
          const effectivePerPage = perPage ?? 100;
          const offset = effectivePage * effectivePerPage;
          const result = await gwClient.listThreads({
            resourceId: effectiveResourceId,
            limit: effectivePerPage,
            offset
          });
          return {
            threads: result.threads.map(chunkLFZO2LHV_cjs.toLocalThread),
            page: effectivePage,
            perPage: effectivePerPage,
            total: result.total,
            hasMore: offset + result.threads.length < result.total
          };
        }
      }
      const filter = effectiveResourceId || metadata ? {} : void 0;
      if (effectiveResourceId) {
        filter.resourceId = effectiveResourceId;
      }
      if (metadata) {
        filter.metadata = metadata;
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (memory) {
        const result = await memory.listThreads(
          shouldFilterThreadsWithFGA(mastra, requestContext) ? {
            filter,
            perPage: false,
            orderBy
          } : {
            filter,
            page,
            perPage,
            orderBy
          }
        );
        if (!shouldFilterThreadsWithFGA(mastra, requestContext)) {
          return result;
        }
        const accessibleThreads = await filterAccessibleThreads({
          mastra,
          requestContext,
          threads: result.threads
        });
        return paginateThreads({
          threads: accessibleThreads,
          page,
          perPage
        });
      }
      const storage = getStorageFromContext({ mastra });
      if (storage) {
        const memoryStore = await storage.getStore("memory");
        if (memoryStore) {
          const result = await memoryStore.listThreads(
            shouldFilterThreadsWithFGA(mastra, requestContext) ? {
              filter,
              perPage: false,
              orderBy
            } : {
              filter,
              page,
              perPage,
              orderBy
            }
          );
          if (!shouldFilterThreadsWithFGA(mastra, requestContext)) {
            return result;
          }
          const accessibleThreads = await filterAccessibleThreads({
            mastra,
            requestContext,
            threads: result.threads
          });
          return paginateThreads({
            threads: accessibleThreads,
            page,
            perPage
          });
        }
      }
      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error listing threads");
    }
  }
});
var GET_THREAD_BY_ID_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.getThreadByIdQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Get thread by ID",
  description: "Returns details for a specific conversation thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, resourceId, requestContext }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      const isGateway = agent ? await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent) : false;
      if (agent && isGateway) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          const result = await gwClient.getThread(effectiveThreadId);
          if (!result) {
            return {
              id: effectiveThreadId,
              resourceId: effectiveResourceId ?? "",
              title: "",
              metadata: {},
              createdAt: /* @__PURE__ */ new Date(),
              updatedAt: /* @__PURE__ */ new Date()
            };
          }
          const thread = chunkLFZO2LHV_cjs.toLocalThread(result.thread);
          await chunkRVD3DGBZ_cjs.enforceThreadAccess({
            mastra,
            requestContext,
            threadId: effectiveThreadId,
            thread,
            effectiveResourceId
          });
          return thread;
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (memory) {
        const thread = await memory.getThreadById({ threadId: effectiveThreadId });
        if (!thread) {
          throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
        }
        await chunkRVD3DGBZ_cjs.enforceThreadAccess({
          mastra,
          requestContext,
          threadId: effectiveThreadId,
          thread,
          effectiveResourceId
        });
        return thread;
      }
      const storage = getStorageFromContext({ mastra });
      if (storage) {
        const memoryStore = await storage.getStore("memory");
        if (memoryStore) {
          const thread = await memoryStore.getThreadById({ threadId: effectiveThreadId });
          if (!thread) {
            throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
          }
          await chunkRVD3DGBZ_cjs.enforceThreadAccess({
            mastra,
            requestContext,
            threadId: effectiveThreadId,
            thread,
            effectiveResourceId
          });
          return thread;
        }
      }
      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting thread");
    }
  }
});
var LIST_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/threads/:threadId/messages",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.listMessagesQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.listMessagesResponseSchema,
  summary: "List thread messages",
  description: "Returns a paginated list of messages in a conversation thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: (async ({
    mastra,
    agentId,
    threadId,
    resourceId,
    perPage,
    page,
    orderBy,
    include,
    filter,
    includeSystemReminders,
    requestContext
  }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      if (!effectiveThreadId) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "No threadId found" });
      }
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          const threadResult = await gwClient.getThread(effectiveThreadId);
          if (threadResult) {
            await chunkRVD3DGBZ_cjs.enforceThreadAccess({
              mastra,
              requestContext,
              threadId: effectiveThreadId,
              thread: chunkLFZO2LHV_cjs.toLocalThread(threadResult.thread),
              effectiveResourceId
            });
          }
          const effectivePage = page ?? 0;
          const effectivePerPage = perPage ?? 100;
          const offset = effectivePage * effectivePerPage;
          const result = await gwClient.listMessages(effectiveThreadId, {
            limit: effectivePerPage,
            offset,
            order: orderBy?.direction?.toLowerCase()
          });
          if (!result) {
            throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
          }
          return {
            messages: result.messages.map(chunkLFZO2LHV_cjs.toLocalMessage),
            uiMessages: result.messages.map(chunkLFZO2LHV_cjs.toLocalMessage)
          };
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (memory) {
        const thread = await memory.getThreadById({ threadId: effectiveThreadId });
        if (!thread) {
          throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
        }
        await chunkRVD3DGBZ_cjs.enforceThreadAccess({
          mastra,
          requestContext,
          threadId: effectiveThreadId,
          thread,
          effectiveResourceId
        });
        const result = await memory.recall({
          threadId: effectiveThreadId,
          resourceId: effectiveResourceId,
          perPage,
          page,
          orderBy,
          include,
          filter,
          includeSystemReminders
        });
        const uiMessages = result.uiMessages;
        return {
          ...result,
          uiMessages: Array.isArray(uiMessages) ? uiMessages : null
        };
      }
      const storage = getStorageFromContext({ mastra });
      if (storage) {
        const memoryStore = await storage.getStore("memory");
        if (memoryStore) {
          const thread = await memoryStore.getThreadById({ threadId: effectiveThreadId });
          if (!thread) {
            throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
          }
          await chunkRVD3DGBZ_cjs.enforceThreadAccess({
            mastra,
            requestContext,
            threadId: effectiveThreadId,
            thread,
            effectiveResourceId
          });
          const result = await memoryStore.listMessages({
            threadId: effectiveThreadId,
            resourceId: effectiveResourceId,
            perPage,
            page,
            orderBy,
            include,
            filter
          });
          return {
            ...result,
            uiMessages: null
          };
        }
      }
      return { messages: [], uiMessages: [] };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting messages");
    }
  })
});
var GET_WORKING_MEMORY_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/threads/:threadId/working-memory",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.getWorkingMemoryQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.getWorkingMemoryResponseSchema,
  summary: "Get working memory",
  description: "Returns the working memory state for a thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, resourceId, requestContext, memoryConfig }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      const gwAgent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (gwAgent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(gwAgent) && chunkLFZO2LHV_cjs.getGatewayClient()) {
        return { workingMemory: null, source: "thread", workingMemoryTemplate: null, threadExists: true };
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (!memory) {
        return { workingMemory: null, source: "thread", workingMemoryTemplate: null, threadExists: false };
      }
      const thread = await memory.getThreadById({ threadId: effectiveThreadId });
      const config = memory.getMergedThreadConfig(memoryConfig || {});
      const source = config.workingMemory?.scope !== "thread" && effectiveResourceId ? "resource" : "thread";
      if (thread || source === "resource") {
        await chunkRVD3DGBZ_cjs.enforceThreadAccess({
          mastra,
          requestContext,
          threadId: effectiveThreadId,
          thread,
          effectiveResourceId
        });
      }
      const threadExists = !!thread;
      const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
      const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(utils.generateEmptyFromSchema(template.content)) } : template;
      const workingMemory = await memory.getWorkingMemory({
        threadId: effectiveThreadId,
        resourceId: effectiveResourceId,
        memoryConfig
      });
      return { workingMemory, source, workingMemoryTemplate, threadExists };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error getting working memory");
    }
  }
});
var SAVE_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/save-messages",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.agentIdQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.saveMessagesBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.saveMessagesResponseSchema,
  summary: "Save messages",
  description: "Saves new messages to memory",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, messages, requestContext }) => {
    try {
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, void 0);
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      if (!messages) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Messages are required" });
      }
      if (!Array.isArray(messages)) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Messages should be an array" });
      }
      const resourceIdByThread = /* @__PURE__ */ new Map();
      for (const message of messages) {
        if (!message.threadId || !message.resourceId) {
          continue;
        }
        const existingResourceId = resourceIdByThread.get(message.threadId);
        if (!existingResourceId) {
          resourceIdByThread.set(message.threadId, message.resourceId);
        } else if (existingResourceId !== message.resourceId) {
          throw new chunk64ITUOXI_cjs.HTTPException(400, {
            message: "All messages for the same threadId must use the same resourceId."
          });
        }
      }
      const invalidMessages = messages.filter((message) => !message.threadId || !message.resourceId);
      if (invalidMessages.length > 0) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, {
          message: `All messages must have threadId and resourceId fields. Found ${invalidMessages.length} invalid message(s).`
        });
      }
      if (effectiveResourceId) {
        const unauthorizedMessages = messages.filter((message) => message.resourceId !== effectiveResourceId);
        if (unauthorizedMessages.length > 0) {
          throw new chunk64ITUOXI_cjs.HTTPException(403, {
            message: "Access denied: cannot save messages for a different resource"
          });
        }
        const threadIds = [...new Set(messages.map((m) => m.threadId).filter(Boolean))];
        for (const threadId of threadIds) {
          const thread = await memory.getThreadById({ threadId });
          await chunkRVD3DGBZ_cjs.enforceThreadAccess({
            mastra,
            requestContext,
            threadId,
            thread,
            effectiveResourceId,
            permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
          });
        }
      } else {
        const threadIds = [...new Set(messages.map((m) => m.threadId).filter(Boolean))];
        for (const threadId of threadIds) {
          const thread = await memory.getThreadById({ threadId });
          await chunkRVD3DGBZ_cjs.enforceThreadAccess({
            mastra,
            requestContext,
            threadId,
            thread,
            effectiveResourceId: resourceIdByThread.get(threadId),
            permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
          });
        }
      }
      const processedMessages = messages.map((message) => ({
        ...message,
        id: message.id || memory.generateId(),
        createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
      }));
      const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
      return result;
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error saving messages");
    }
  }
});
var CREATE_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/threads",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.agentIdQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.createThreadBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Create thread",
  description: "Creates a new conversation thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, title, metadata, threadId, requestContext }) => {
    try {
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      const effectiveThreadId = threadId ?? mastra.generateId();
      chunkRVD3DGBZ_cjs.validateBody({ resourceId: effectiveResourceId });
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveThreadId,
        effectiveResourceId,
        permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
      });
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          const result2 = await gwClient.createThread({
            id: effectiveThreadId,
            resourceId: effectiveResourceId,
            title,
            metadata
          });
          return chunkLFZO2LHV_cjs.toLocalThread(result2.thread);
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const result = await memory.createThread({
        resourceId: effectiveResourceId,
        title,
        metadata,
        threadId: effectiveThreadId
      });
      return result;
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error saving thread to memory");
    }
  }
});
var UPDATE_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "PATCH",
  path: "/memory/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.agentIdQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.updateThreadBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Update thread",
  description: "Updates a conversation thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, title, metadata, resourceId, requestContext }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          const existing = await gwClient.getThread(effectiveThreadId);
          if (existing) {
            await chunkRVD3DGBZ_cjs.enforceThreadAccess({
              mastra,
              requestContext,
              threadId: effectiveThreadId,
              thread: chunkLFZO2LHV_cjs.toLocalThread(existing.thread),
              effectiveResourceId,
              permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
            });
          }
          const result2 = await gwClient.updateThread(effectiveThreadId, { title, metadata });
          if (!result2) {
            throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
          }
          return chunkLFZO2LHV_cjs.toLocalThread(result2.thread);
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      const updatedAt = /* @__PURE__ */ new Date();
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const thread = await memory.getThreadById({ threadId: effectiveThreadId });
      if (!thread) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
      }
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveThreadId,
        thread,
        effectiveResourceId,
        permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
      });
      const updatedThread = {
        ...thread,
        title: title || thread.title,
        metadata: metadata || thread.metadata,
        // Don't allow changing resourceId if effectiveResourceId is set (prevents reassigning threads)
        resourceId: effectiveResourceId || resourceId || thread.resourceId,
        createdAt: thread.createdAt,
        updatedAt
      };
      const result = await memory.saveThread({ thread: updatedThread });
      return {
        ...result,
        resourceId: result.resourceId ?? null
      };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error updating thread");
    }
  }
});
var DELETE_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "DELETE",
  path: "/memory/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.deleteThreadQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.deleteThreadResponseSchema,
  summary: "Delete thread",
  description: "Deletes a conversation thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, resourceId, requestContext }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent)) {
        const gwClient = chunkLFZO2LHV_cjs.getGatewayClient();
        if (gwClient) {
          const existing = await gwClient.getThread(effectiveThreadId);
          if (existing) {
            await chunkRVD3DGBZ_cjs.enforceThreadAccess({
              mastra,
              requestContext,
              threadId: effectiveThreadId,
              thread: chunkLFZO2LHV_cjs.toLocalThread(existing.thread),
              effectiveResourceId,
              permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_DELETE
            });
          }
          const deleteResult = await gwClient.deleteThread(effectiveThreadId);
          if (!deleteResult.ok) {
            throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found on gateway" });
          }
          return { result: "Thread deleted" };
        }
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const thread = await memory.getThreadById({ threadId: effectiveThreadId });
      if (!thread) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
      }
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveThreadId,
        thread,
        effectiveResourceId,
        permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_DELETE
      });
      await memory.deleteThread(effectiveThreadId);
      return { result: "Thread deleted" };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error deleting thread");
    }
  }
});
var CLONE_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/threads/:threadId/clone",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.agentIdQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.cloneThreadBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.cloneThreadResponseSchema,
  summary: "Clone thread",
  description: "Creates a copy of a conversation thread with all its messages",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, newThreadId, resourceId, title, metadata, options, requestContext }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      const effectiveNewThreadId = newThreadId ?? mastra.generateId();
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId });
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const sourceThread = await memory.getThreadById({ threadId: effectiveThreadId });
      if (!sourceThread) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Source thread not found" });
      }
      const cloneResourceId = effectiveResourceId ?? sourceThread.resourceId ?? void 0;
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveThreadId,
        thread: sourceThread,
        effectiveResourceId
      });
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveNewThreadId,
        effectiveResourceId: cloneResourceId,
        permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
      });
      const result = await memory.cloneThread({
        sourceThreadId: effectiveThreadId,
        newThreadId: effectiveNewThreadId,
        resourceId: cloneResourceId,
        title,
        metadata,
        options
      });
      return result;
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error cloning thread");
    }
  }
});
var UPDATE_WORKING_MEMORY_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/threads/:threadId/working-memory",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.agentIdQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.updateWorkingMemoryBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.updateWorkingMemoryResponseSchema,
  summary: "Update working memory",
  description: "Updates the working memory state for a thread",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, threadId, resourceId, memoryConfig, workingMemory, requestContext }) => {
    try {
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      chunkRVD3DGBZ_cjs.validateBody({ threadId: effectiveThreadId, workingMemory });
      const gwAgent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (gwAgent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(gwAgent) && chunkLFZO2LHV_cjs.getGatewayClient()) {
        return { success: true };
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const thread = await memory.getThreadById({ threadId: effectiveThreadId });
      if (!thread) {
        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
      }
      await chunkRVD3DGBZ_cjs.enforceThreadAccess({
        mastra,
        requestContext,
        threadId: effectiveThreadId,
        thread,
        effectiveResourceId,
        permission: chunkRVD3DGBZ_cjs.MastraFGAPermissions.MEMORY_WRITE
      });
      await memory.updateWorkingMemory({
        threadId: effectiveThreadId,
        resourceId: effectiveResourceId,
        workingMemory,
        memoryConfig
      });
      return { success: true };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error updating working memory");
    }
  }
});
var DELETE_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/messages/delete",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.deleteMessagesQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.deleteMessagesBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.deleteMessagesResponseSchema,
  summary: "Delete messages",
  description: "Deletes specific messages from memory",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, resourceId, messageIds, requestContext }) => {
    try {
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      if (messageIds === void 0 || messageIds === null) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "messageIds is required" });
      }
      let normalizedIds;
      if (Array.isArray(messageIds)) {
        normalizedIds = messageIds;
      } else if (typeof messageIds === "string") {
        normalizedIds = [messageIds];
      } else {
        normalizedIds = [messageIds];
      }
      const stringIds = normalizedIds.map((id) => typeof id === "string" ? id : id.id);
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext, allowMissingAgent: true });
      if (effectiveResourceId && stringIds.length > 0) {
        const storage = memory?.storage || getStorageFromContext({ mastra });
        if (!storage) {
          throw new chunk64ITUOXI_cjs.HTTPException(403, { message: "Access denied: unable to verify message ownership" });
        }
        const memoryStore = await storage.getStore("memory");
        if (!memoryStore) {
          throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
        }
        await enforceDeleteMessagesThreadAccess({
          mastra,
          requestContext,
          memoryStore,
          messageIds: stringIds,
          effectiveResourceId
        });
      } else if (stringIds.length > 0) {
        const storage = memory?.storage || getStorageFromContext({ mastra });
        if (!storage) {
          throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
        }
        const memoryStore = await storage.getStore("memory");
        if (!memoryStore) {
          throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
        }
        await enforceDeleteMessagesThreadAccess({
          mastra,
          requestContext,
          memoryStore,
          messageIds: stringIds
        });
      }
      if (memory) {
        await memory.deleteMessages(normalizedIds);
      } else {
        const storage = getStorageFromContext({ mastra });
        if (storage) {
          const memoryStore = await storage.getStore("memory");
          if (memoryStore) {
            await memoryStore.deleteMessages(stringIds);
          } else {
            throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
          }
        } else {
          throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
        }
      }
      const count = Array.isArray(messageIds) ? messageIds.length : 1;
      return { success: true, message: `${count} message${count === 1 ? "" : "s"} deleted successfully` };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error deleting messages");
    }
  }
});
var SEARCH_MEMORY_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/search",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.searchMemoryQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.searchMemoryResponseSchema,
  summary: "Search memory",
  description: "Searches across memory using semantic or text search",
  tags: ["Memory"],
  requiresAuth: true,
  handler: async ({ mastra, agentId, searchQuery, resourceId, threadId, limit = 20, requestContext, memoryConfig }) => {
    try {
      const effectiveResourceId = chunkRVD3DGBZ_cjs.getEffectiveResourceId(requestContext, resourceId);
      const effectiveThreadId = chunkRVD3DGBZ_cjs.getEffectiveThreadId(requestContext, threadId);
      chunkRVD3DGBZ_cjs.validateBody({ searchQuery, resourceId: effectiveResourceId });
      const agent = await getAgentFromContext({ mastra, agentId, requestContext });
      if (agent && await chunkLFZO2LHV_cjs.isGatewayAgentAsync(agent) && chunkLFZO2LHV_cjs.getGatewayClient()) {
        return {
          results: [],
          count: 0,
          query: searchQuery,
          searchScope: "resource",
          searchType: "semantic"
        };
      }
      const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
      if (!memory) {
        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
      }
      const config = memory.getMergedThreadConfig(memoryConfig || {});
      const hasSemanticRecall = !!config?.semanticRecall;
      const resourceScope = typeof config?.semanticRecall === "object" ? config?.semanticRecall?.scope !== "thread" : true;
      const searchResults = [];
      let accessibleThreadsForResource;
      let accessibleThreadIds;
      if (resourceScope && effectiveResourceId && shouldFilterThreadsWithFGA(mastra, requestContext)) {
        const { threads } = await memory.listThreads({
          filter: { resourceId: effectiveResourceId },
          perPage: false,
          orderBy: { field: "updatedAt", direction: "DESC" }
        });
        accessibleThreadsForResource = await filterAccessibleThreads({
          mastra,
          requestContext,
          threads
        });
        accessibleThreadIds = new Set(accessibleThreadsForResource.map((thread) => thread.id));
        if (accessibleThreadsForResource.length === 0) {
          return {
            results: [],
            count: 0,
            query: searchQuery,
            searchScope: resourceScope ? "resource" : "thread",
            searchType: hasSemanticRecall ? "semantic" : "text"
          };
        }
      }
      if (effectiveThreadId && !resourceScope) {
        const thread = await memory.getThreadById({ threadId: effectiveThreadId });
        if (!thread) {
          return {
            results: [],
            count: 0,
            query: searchQuery,
            searchScope: resourceScope ? "resource" : "thread",
            searchType: hasSemanticRecall ? "semantic" : "text"
          };
        }
        await chunkRVD3DGBZ_cjs.enforceThreadAccess({
          mastra,
          requestContext,
          threadId: effectiveThreadId,
          thread,
          effectiveResourceId
        });
      }
      let searchThreadId = effectiveThreadId;
      if (!searchThreadId) {
        const threads = accessibleThreadsForResource ?? (await memory.listThreads({
          filter: { resourceId: effectiveResourceId },
          page: 0,
          perPage: 1,
          orderBy: { field: "updatedAt", direction: "DESC" }
        })).threads;
        if (threads.length === 0) {
          return {
            results: [],
            count: 0,
            query: searchQuery,
            searchScope: resourceScope ? "resource" : "thread",
            searchType: hasSemanticRecall ? "semantic" : "text"
          };
        }
        searchThreadId = threads[0].id;
      }
      const beforeRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.before || 2;
      const afterRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.after || 2;
      if (resourceScope && config.semanticRecall) {
        config.semanticRecall = typeof config.semanticRecall === `boolean` ? (
          // make message range 0 so we can highlight the matches in search, message range will include other messages, not the matching ones
          // and we add prev/next messages in a special section on each message anyway
          { messageRange: 0, topK: 2, scope: "resource" }
        ) : { ...config.semanticRecall, messageRange: 0 };
      }
      const threadConfig = memory.getMergedThreadConfig(config || {});
      if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
        return { results: [], count: 0, query: searchQuery };
      }
      const result = await memory.recall({
        threadId: searchThreadId,
        resourceId: effectiveResourceId,
        perPage: threadConfig.lastMessages,
        threadConfig: config,
        vectorSearchString: threadConfig.semanticRecall && searchQuery ? searchQuery : void 0
      });
      const accessibleMessages = accessibleThreadIds ? result.messages.filter(
        (message) => accessibleThreadIds.has(message.threadId || searchThreadId)
      ) : result.messages;
      if (accessibleMessages.length === 0) {
        return {
          results: [],
          count: 0,
          query: searchQuery,
          searchScope: resourceScope ? "resource" : "thread",
          searchType: hasSemanticRecall ? "semantic" : "text"
        };
      }
      const threadIds = Array.from(
        new Set(accessibleMessages.map((m) => m.threadId || searchThreadId).filter(Boolean))
      );
      const fetched = await Promise.all(threadIds.map((id) => memory.getThreadById({ threadId: id })));
      const threadMap = new Map(fetched.filter(Boolean).map((t) => [t.id, t]));
      for (const msg of accessibleMessages) {
        const content = getTextContent(msg);
        const msgThreadId = msg.threadId || searchThreadId;
        const thread = threadMap.get(msgThreadId);
        const threadMessages = (await memory.recall({ threadId: msgThreadId })).messages;
        const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
        const searchResult = {
          id: msg.id,
          role: msg.role,
          content,
          createdAt: msg.createdAt,
          threadId: msgThreadId,
          threadTitle: thread?.title || msgThreadId
        };
        if (messageIndex !== -1) {
          searchResult.context = {
            before: threadMessages.slice(Math.max(0, messageIndex - beforeRange), messageIndex).map((m) => ({
              id: m.id,
              role: m.role,
              content: getTextContent(m),
              createdAt: m.createdAt || /* @__PURE__ */ new Date()
            })),
            after: threadMessages.slice(messageIndex + 1, messageIndex + afterRange + 1).map((m) => ({
              id: m.id,
              role: m.role,
              content: getTextContent(m),
              createdAt: m.createdAt || /* @__PURE__ */ new Date()
            }))
          };
        }
        searchResults.push(searchResult);
      }
      const sortedResults = searchResults.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
      return {
        results: sortedResults,
        count: sortedResults.length,
        query: searchQuery,
        searchScope: resourceScope ? "resource" : "thread",
        searchType: hasSemanticRecall ? "semantic" : "text"
      };
    } catch (error) {
      return chunkZ7LCIYK7_cjs.handleError(error, "Error searching memory");
    }
  }
});
var GET_MEMORY_STATUS_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/network/status",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.getMemoryStatusNetworkQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.memoryStatusResponseSchema,
  summary: "Get memory status (network)",
  description: "Returns the current status of the memory system (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: GET_MEMORY_STATUS_ROUTE.handler
});
var LIST_THREADS_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/network/threads",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.listThreadsNetworkQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.listThreadsResponseSchema,
  summary: "List memory threads (network)",
  description: "Returns a paginated list of conversation threads (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: LIST_THREADS_ROUTE.handler
});
var GET_THREAD_BY_ID_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/network/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.getThreadByIdNetworkQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Get thread by ID (network)",
  description: "Returns details for a specific conversation thread (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: GET_THREAD_BY_ID_ROUTE.handler
});
var LIST_MESSAGES_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "GET",
  path: "/memory/network/threads/:threadId/messages",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.listMessagesNetworkQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.listMessagesResponseSchema,
  summary: "List thread messages (network)",
  description: "Returns a paginated list of messages in a conversation thread (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: LIST_MESSAGES_ROUTE.handler
});
var SAVE_MESSAGES_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/network/save-messages",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.saveMessagesNetworkQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.saveMessagesBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.saveMessagesResponseSchema,
  summary: "Save messages (network)",
  description: "Saves new messages to memory (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: SAVE_MESSAGES_ROUTE.handler
});
var CREATE_THREAD_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/network/threads",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.createThreadNetworkQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.createThreadBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Create thread (network)",
  description: "Creates a new conversation thread (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: CREATE_THREAD_ROUTE.handler
});
var UPDATE_THREAD_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "PATCH",
  path: "/memory/network/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.updateThreadNetworkQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.updateThreadBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.getThreadByIdResponseSchema,
  summary: "Update thread (network)",
  description: "Updates a conversation thread (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: UPDATE_THREAD_ROUTE.handler
});
var DELETE_THREAD_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "DELETE",
  path: "/memory/network/threads/:threadId",
  responseType: "json",
  pathParamSchema: chunkNOXRQV2G_cjs.threadIdPathParams,
  queryParamSchema: chunkNOXRQV2G_cjs.deleteThreadNetworkQuerySchema,
  responseSchema: chunkNOXRQV2G_cjs.deleteThreadResponseSchema,
  summary: "Delete thread (network)",
  description: "Deletes a conversation thread (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: DELETE_THREAD_ROUTE.handler
});
var DELETE_MESSAGES_NETWORK_ROUTE = chunkG54X6VE6_cjs.createRoute({
  method: "POST",
  path: "/memory/network/messages/delete",
  responseType: "json",
  queryParamSchema: chunkNOXRQV2G_cjs.deleteMessagesNetworkQuerySchema,
  bodySchema: chunkNOXRQV2G_cjs.deleteMessagesBodySchema,
  responseSchema: chunkNOXRQV2G_cjs.deleteMessagesResponseSchema,
  summary: "Delete messages (network)",
  description: "Deletes specific messages from memory (network route)",
  tags: ["Memory - Network"],
  requiresAuth: true,
  handler: DELETE_MESSAGES_ROUTE.handler
});

exports.AWAIT_BUFFER_STATUS_ROUTE = AWAIT_BUFFER_STATUS_ROUTE;
exports.CLONE_THREAD_ROUTE = CLONE_THREAD_ROUTE;
exports.CREATE_THREAD_NETWORK_ROUTE = CREATE_THREAD_NETWORK_ROUTE;
exports.CREATE_THREAD_ROUTE = CREATE_THREAD_ROUTE;
exports.DELETE_MESSAGES_NETWORK_ROUTE = DELETE_MESSAGES_NETWORK_ROUTE;
exports.DELETE_MESSAGES_ROUTE = DELETE_MESSAGES_ROUTE;
exports.DELETE_THREAD_NETWORK_ROUTE = DELETE_THREAD_NETWORK_ROUTE;
exports.DELETE_THREAD_ROUTE = DELETE_THREAD_ROUTE;
exports.GET_MEMORY_CONFIG_ROUTE = GET_MEMORY_CONFIG_ROUTE;
exports.GET_MEMORY_STATUS_NETWORK_ROUTE = GET_MEMORY_STATUS_NETWORK_ROUTE;
exports.GET_MEMORY_STATUS_ROUTE = GET_MEMORY_STATUS_ROUTE;
exports.GET_OBSERVATIONAL_MEMORY_ROUTE = GET_OBSERVATIONAL_MEMORY_ROUTE;
exports.GET_THREAD_BY_ID_NETWORK_ROUTE = GET_THREAD_BY_ID_NETWORK_ROUTE;
exports.GET_THREAD_BY_ID_ROUTE = GET_THREAD_BY_ID_ROUTE;
exports.GET_WORKING_MEMORY_ROUTE = GET_WORKING_MEMORY_ROUTE;
exports.LIST_MESSAGES_NETWORK_ROUTE = LIST_MESSAGES_NETWORK_ROUTE;
exports.LIST_MESSAGES_ROUTE = LIST_MESSAGES_ROUTE;
exports.LIST_THREADS_NETWORK_ROUTE = LIST_THREADS_NETWORK_ROUTE;
exports.LIST_THREADS_ROUTE = LIST_THREADS_ROUTE;
exports.SAVE_MESSAGES_NETWORK_ROUTE = SAVE_MESSAGES_NETWORK_ROUTE;
exports.SAVE_MESSAGES_ROUTE = SAVE_MESSAGES_ROUTE;
exports.SEARCH_MEMORY_ROUTE = SEARCH_MEMORY_ROUTE;
exports.UPDATE_THREAD_NETWORK_ROUTE = UPDATE_THREAD_NETWORK_ROUTE;
exports.UPDATE_THREAD_ROUTE = UPDATE_THREAD_ROUTE;
exports.UPDATE_WORKING_MEMORY_ROUTE = UPDATE_WORKING_MEMORY_ROUTE;
exports.getTextContent = getTextContent;
exports.memory_exports = memory_exports;
//# sourceMappingURL=chunk-6HRGFBAF.cjs.map
//# sourceMappingURL=chunk-6HRGFBAF.cjs.map