'use strict';

var chunkC3U5LR4X_cjs = require('../../chunk-C3U5LR4X.cjs');
var chunkR2DKW2EK_cjs = require('../../chunk-R2DKW2EK.cjs');
var chunkHERQV6YY_cjs = require('../../chunk-HERQV6YY.cjs');
var chunkQQGEBRIG_cjs = require('../../chunk-QQGEBRIG.cjs');
var chunk6T2DK2GP_cjs = require('../../chunk-6T2DK2GP.cjs');
var chunkJGK2MALT_cjs = require('../../chunk-JGK2MALT.cjs');
var chunkJWCTCYDF_cjs = require('../../chunk-JWCTCYDF.cjs');
var chunkDK4A344H_cjs = require('../../chunk-DK4A344H.cjs');
var chunkSI3B7F4U_cjs = require('../../chunk-SI3B7F4U.cjs');
var chunkTSMZEPL3_cjs = require('../../chunk-TSMZEPL3.cjs');
var chunkTKBRQY5C_cjs = require('../../chunk-TKBRQY5C.cjs');
var chunkW34IV6DV_cjs = require('../../chunk-W34IV6DV.cjs');
var chunkLTJHINYX_cjs = require('../../chunk-LTJHINYX.cjs');
var chunkP445W4ET_cjs = require('../../chunk-P445W4ET.cjs');
var chunkDMAGP2MP_cjs = require('../../chunk-DMAGP2MP.cjs');
var chunkCMGZD5UE_cjs = require('../../chunk-CMGZD5UE.cjs');
var chunkPEG4SKER_cjs = require('../../chunk-PEG4SKER.cjs');
var chunkHOAPZDJV_cjs = require('../../chunk-HOAPZDJV.cjs');
var chunkLKBYAMJS_cjs = require('../../chunk-LKBYAMJS.cjs');
var chunkLNIERC4T_cjs = require('../../chunk-LNIERC4T.cjs');
var chunkGU5KJAMA_cjs = require('../../chunk-GU5KJAMA.cjs');
var chunkNSB6AGO3_cjs = require('../../chunk-NSB6AGO3.cjs');
var chunk6LFZL6QU_cjs = require('../../chunk-6LFZL6QU.cjs');
var chunkALE53JHX_cjs = require('../../chunk-ALE53JHX.cjs');
var chunkQVMLEJ63_cjs = require('../../chunk-QVMLEJ63.cjs');
var chunkF4HPG2WH_cjs = require('../../chunk-F4HPG2WH.cjs');
var chunkZ2QBLWUE_cjs = require('../../chunk-Z2QBLWUE.cjs');
var chunkQOLNS6MT_cjs = require('../../chunk-QOLNS6MT.cjs');
var chunkFBIKXU4U_cjs = require('../../chunk-FBIKXU4U.cjs');
var chunkSTHQS3QR_cjs = require('../../chunk-STHQS3QR.cjs');
var chunkEFX5WYRT_cjs = require('../../chunk-EFX5WYRT.cjs');
var chunkY2BKW5ND_cjs = require('../../chunk-Y2BKW5ND.cjs');
var chunk6P7P7Y5U_cjs = require('../../chunk-6P7P7Y5U.cjs');
var requestContext = require('@mastra/core/request-context');
var server = require('@mastra/core/server');
var hono = require('hono');
var v4 = require('zod/v4');

// src/server/server-adapter/routes/a2a.ts
var A2A_ROUTES = [chunkF4HPG2WH_cjs.GET_AGENT_CARD_ROUTE, chunkF4HPG2WH_cjs.AGENT_EXECUTION_ROUTE];

// src/server/server-adapter/routes/agent-builder.ts
var AGENT_BUILDER_ROUTES = [
  chunkZ2QBLWUE_cjs.LIST_AGENT_BUILDER_ACTIONS_ROUTE,
  chunkZ2QBLWUE_cjs.GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE,
  chunkZ2QBLWUE_cjs.LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE,
  chunkZ2QBLWUE_cjs.GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE,
  chunkZ2QBLWUE_cjs.CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE,
  chunkZ2QBLWUE_cjs.STREAM_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.START_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.START_AGENT_BUILDER_ACTION_RUN_ROUTE,
  chunkZ2QBLWUE_cjs.OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.RESUME_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE
];

// src/server/server-adapter/routes/agents.ts
var AGENTS_ROUTES = [
  // ============================================================================
  // Agent Core Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.LIST_AGENTS_ROUTE,
  chunkSTHQS3QR_cjs.GET_PROVIDERS_ROUTE,
  chunkSTHQS3QR_cjs.GET_AGENT_BY_ID_ROUTE,
  chunkSTHQS3QR_cjs.CLONE_AGENT_ROUTE,
  // ============================================================================
  // Voice Routes
  // ============================================================================
  chunkPEG4SKER_cjs.GET_SPEAKERS_ROUTE,
  chunkPEG4SKER_cjs.GET_SPEAKERS_DEPRECATED_ROUTE,
  // ============================================================================
  // Agent Execution Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.GENERATE_AGENT_ROUTE,
  chunkSTHQS3QR_cjs.GENERATE_AGENT_VNEXT_ROUTE,
  chunkSTHQS3QR_cjs.STREAM_GENERATE_ROUTE,
  chunkSTHQS3QR_cjs.STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE,
  // ============================================================================
  // Tool Routes
  // ============================================================================
  chunkLKBYAMJS_cjs.EXECUTE_AGENT_TOOL_ROUTE,
  chunkSTHQS3QR_cjs.APPROVE_TOOL_CALL_ROUTE,
  chunkSTHQS3QR_cjs.DECLINE_TOOL_CALL_ROUTE,
  chunkSTHQS3QR_cjs.APPROVE_TOOL_CALL_GENERATE_ROUTE,
  chunkSTHQS3QR_cjs.DECLINE_TOOL_CALL_GENERATE_ROUTE,
  chunkSTHQS3QR_cjs.APPROVE_NETWORK_TOOL_CALL_ROUTE,
  chunkSTHQS3QR_cjs.DECLINE_NETWORK_TOOL_CALL_ROUTE,
  // ============================================================================
  // Network Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.STREAM_NETWORK_ROUTE,
  // ============================================================================
  // Model Management Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.UPDATE_AGENT_MODEL_ROUTE,
  chunkSTHQS3QR_cjs.RESET_AGENT_MODEL_ROUTE,
  chunkSTHQS3QR_cjs.REORDER_AGENT_MODEL_LIST_ROUTE,
  chunkSTHQS3QR_cjs.UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE,
  // ============================================================================
  // Instruction Enhancement Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.ENHANCE_INSTRUCTIONS_ROUTE,
  // ============================================================================
  // Agent Tool Routes
  // ============================================================================
  chunkLKBYAMJS_cjs.GET_AGENT_TOOL_ROUTE,
  // ============================================================================
  // Agent Skill Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.GET_AGENT_SKILL_ROUTE,
  // ============================================================================
  // Voice/Speech Routes
  // ============================================================================
  chunkPEG4SKER_cjs.GENERATE_SPEECH_ROUTE,
  chunkPEG4SKER_cjs.GENERATE_SPEECH_DEPRECATED_ROUTE,
  chunkPEG4SKER_cjs.TRANSCRIBE_SPEECH_ROUTE,
  chunkPEG4SKER_cjs.TRANSCRIBE_SPEECH_DEPRECATED_ROUTE,
  chunkPEG4SKER_cjs.GET_LISTENER_ROUTE,
  // ============================================================================
  // Deprecated Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.STREAM_VNEXT_DEPRECATED_ROUTE,
  chunkSTHQS3QR_cjs.STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE,
  chunkSTHQS3QR_cjs.STREAM_UI_MESSAGE_DEPRECATED_ROUTE
];

// src/server/server-adapter/routes/datasets.ts
var DATASETS_ROUTES = [
  // Dataset CRUD
  chunkP445W4ET_cjs.LIST_DATASETS_ROUTE,
  chunkP445W4ET_cjs.CREATE_DATASET_ROUTE,
  chunkP445W4ET_cjs.GET_DATASET_ROUTE,
  chunkP445W4ET_cjs.UPDATE_DATASET_ROUTE,
  chunkP445W4ET_cjs.DELETE_DATASET_ROUTE,
  // Item list and add
  chunkP445W4ET_cjs.LIST_ITEMS_ROUTE,
  chunkP445W4ET_cjs.ADD_ITEM_ROUTE,
  // Batch operations - MUST come before item-specific routes to avoid /items/batch matching /items/:itemId
  chunkP445W4ET_cjs.BATCH_INSERT_ITEMS_ROUTE,
  chunkP445W4ET_cjs.BATCH_DELETE_ITEMS_ROUTE,
  // Item-specific CRUD (uses :itemId param)
  chunkP445W4ET_cjs.GET_ITEM_ROUTE,
  chunkP445W4ET_cjs.UPDATE_ITEM_ROUTE,
  chunkP445W4ET_cjs.DELETE_ITEM_ROUTE,
  // Version operations
  chunkP445W4ET_cjs.LIST_DATASET_VERSIONS_ROUTE,
  chunkP445W4ET_cjs.LIST_ITEM_VERSIONS_ROUTE,
  chunkP445W4ET_cjs.GET_ITEM_VERSION_ROUTE,
  // Experiment operations
  chunkP445W4ET_cjs.LIST_EXPERIMENTS_ROUTE,
  chunkP445W4ET_cjs.TRIGGER_EXPERIMENT_ROUTE,
  chunkP445W4ET_cjs.GET_EXPERIMENT_ROUTE,
  chunkP445W4ET_cjs.LIST_EXPERIMENT_RESULTS_ROUTE,
  // Analytics
  chunkP445W4ET_cjs.COMPARE_EXPERIMENTS_ROUTE
];

// src/server/server-adapter/routes/legacy.ts
var LEGACY_ROUTES = [
  // ============================================================================
  // Legacy Agent Routes
  // ============================================================================
  chunkSTHQS3QR_cjs.GENERATE_LEGACY_ROUTE,
  chunkSTHQS3QR_cjs.STREAM_GENERATE_LEGACY_ROUTE,
  // ============================================================================
  // Legacy Workflow Routes
  // ============================================================================
  chunkQOLNS6MT_cjs.STREAM_LEGACY_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE,
  // ============================================================================
  // Legacy Agent Builder Routes
  // ============================================================================
  chunkZ2QBLWUE_cjs.STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE,
  chunkZ2QBLWUE_cjs.OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE
];

// src/server/server-adapter/routes/logs.ts
var LOGS_ROUTES = [chunkGU5KJAMA_cjs.LIST_LOG_TRANSPORTS_ROUTE, chunkGU5KJAMA_cjs.LIST_LOGS_ROUTE, chunkGU5KJAMA_cjs.LIST_LOGS_BY_RUN_ID_ROUTE];

// src/server/server-adapter/routes/mcp.ts
var MCP_ROUTES = [
  // ============================================================================
  // MCP Server Registry Routes
  // ============================================================================
  chunkNSB6AGO3_cjs.LIST_MCP_SERVERS_ROUTE,
  chunkNSB6AGO3_cjs.GET_MCP_SERVER_DETAIL_ROUTE,
  // ============================================================================
  // MCP Server Tool Routes
  // ============================================================================
  chunkNSB6AGO3_cjs.LIST_MCP_SERVER_TOOLS_ROUTE,
  chunkNSB6AGO3_cjs.GET_MCP_SERVER_TOOL_DETAIL_ROUTE,
  chunkNSB6AGO3_cjs.EXECUTE_MCP_SERVER_TOOL_ROUTE,
  // ============================================================================
  // MCP Transport Routes (handled by adapters)
  // ============================================================================
  chunkNSB6AGO3_cjs.MCP_HTTP_TRANSPORT_ROUTE,
  chunkNSB6AGO3_cjs.MCP_SSE_TRANSPORT_ROUTE,
  chunkNSB6AGO3_cjs.MCP_SSE_MESSAGES_ROUTE
];

// src/server/server-adapter/routes/memory.ts
var MEMORY_ROUTES = [
  chunk6LFZL6QU_cjs.GET_MEMORY_STATUS_ROUTE,
  chunk6LFZL6QU_cjs.GET_MEMORY_CONFIG_ROUTE,
  chunk6LFZL6QU_cjs.GET_OBSERVATIONAL_MEMORY_ROUTE,
  chunk6LFZL6QU_cjs.AWAIT_BUFFER_STATUS_ROUTE,
  chunk6LFZL6QU_cjs.LIST_THREADS_ROUTE,
  chunk6LFZL6QU_cjs.GET_THREAD_BY_ID_ROUTE,
  chunk6LFZL6QU_cjs.LIST_MESSAGES_ROUTE,
  chunk6LFZL6QU_cjs.GET_WORKING_MEMORY_ROUTE,
  chunk6LFZL6QU_cjs.SAVE_MESSAGES_ROUTE,
  chunk6LFZL6QU_cjs.CREATE_THREAD_ROUTE,
  chunk6LFZL6QU_cjs.UPDATE_THREAD_ROUTE,
  chunk6LFZL6QU_cjs.DELETE_THREAD_ROUTE,
  chunk6LFZL6QU_cjs.CLONE_THREAD_ROUTE,
  chunk6LFZL6QU_cjs.UPDATE_WORKING_MEMORY_ROUTE,
  chunk6LFZL6QU_cjs.DELETE_MESSAGES_ROUTE,
  chunk6LFZL6QU_cjs.SEARCH_MEMORY_ROUTE,
  chunk6LFZL6QU_cjs.GET_MEMORY_STATUS_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.LIST_THREADS_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.GET_THREAD_BY_ID_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.LIST_MESSAGES_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.SAVE_MESSAGES_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.CREATE_THREAD_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.UPDATE_THREAD_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.DELETE_THREAD_NETWORK_ROUTE,
  chunk6LFZL6QU_cjs.DELETE_MESSAGES_NETWORK_ROUTE
];

// src/server/server-adapter/routes/observability.ts
var OBSERVABILITY_ROUTES = [
  chunkALE53JHX_cjs.LIST_TRACES_ROUTE,
  chunkALE53JHX_cjs.GET_TRACE_ROUTE,
  chunkALE53JHX_cjs.SCORE_TRACES_ROUTE,
  chunkALE53JHX_cjs.LIST_SCORES_BY_SPAN_ROUTE
];

// src/server/server-adapter/routes/processor-providers.ts
var PROCESSOR_PROVIDER_ROUTES = [chunkJGK2MALT_cjs.LIST_PROCESSOR_PROVIDERS_ROUTE, chunkJGK2MALT_cjs.GET_PROCESSOR_PROVIDER_ROUTE];

// src/server/server-adapter/routes/processors.ts
var PROCESSORS_ROUTES = [chunkJWCTCYDF_cjs.LIST_PROCESSORS_ROUTE, chunkJWCTCYDF_cjs.GET_PROCESSOR_BY_ID_ROUTE, chunkJWCTCYDF_cjs.EXECUTE_PROCESSOR_ROUTE];

// src/server/server-adapter/routes/scorers.ts
var SCORES_ROUTES = [
  chunkLNIERC4T_cjs.LIST_SCORERS_ROUTE,
  chunkLNIERC4T_cjs.GET_SCORER_ROUTE,
  chunkLNIERC4T_cjs.LIST_SCORES_BY_RUN_ID_ROUTE,
  chunkLNIERC4T_cjs.LIST_SCORES_BY_SCORER_ID_ROUTE,
  chunkLNIERC4T_cjs.LIST_SCORES_BY_ENTITY_ID_ROUTE,
  chunkLNIERC4T_cjs.SAVE_SCORE_ROUTE
];

// src/server/server-adapter/routes/stored-agents.ts
var STORED_AGENTS_ROUTES = [
  // ============================================================================
  // Stored Agents CRUD Routes
  // IMPORTANT: Routes with literal paths (e.g., /preview-instructions) must come
  // BEFORE routes with path parameters (e.g., /:storedAgentId) to ensure correct matching.
  // ============================================================================
  chunkTSMZEPL3_cjs.LIST_STORED_AGENTS_ROUTE,
  chunkTSMZEPL3_cjs.PREVIEW_INSTRUCTIONS_ROUTE,
  // Must be before GET_STORED_AGENT_ROUTE
  chunkTSMZEPL3_cjs.GET_STORED_AGENT_ROUTE,
  chunkTSMZEPL3_cjs.CREATE_STORED_AGENT_ROUTE,
  chunkTSMZEPL3_cjs.UPDATE_STORED_AGENT_ROUTE,
  chunkTSMZEPL3_cjs.DELETE_STORED_AGENT_ROUTE,
  // ============================================================================
  // Agent Versions Routes
  // IMPORTANT: Routes with literal paths (e.g., /compare) must come BEFORE
  // routes with path parameters (e.g., /:versionId) to ensure correct matching.
  // ============================================================================
  chunkFBIKXU4U_cjs.LIST_AGENT_VERSIONS_ROUTE,
  chunkFBIKXU4U_cjs.CREATE_AGENT_VERSION_ROUTE,
  chunkFBIKXU4U_cjs.COMPARE_AGENT_VERSIONS_ROUTE,
  // Must be before GET_AGENT_VERSION_ROUTE
  chunkFBIKXU4U_cjs.GET_AGENT_VERSION_ROUTE,
  chunkFBIKXU4U_cjs.ACTIVATE_AGENT_VERSION_ROUTE,
  chunkFBIKXU4U_cjs.RESTORE_AGENT_VERSION_ROUTE,
  chunkFBIKXU4U_cjs.DELETE_AGENT_VERSION_ROUTE
];

// src/server/server-adapter/routes/stored-mcp-clients.ts
var STORED_MCP_CLIENTS_ROUTES = [
  // Stored MCP Clients CRUD Routes
  chunkTKBRQY5C_cjs.LIST_STORED_MCP_CLIENTS_ROUTE,
  chunkTKBRQY5C_cjs.GET_STORED_MCP_CLIENT_ROUTE,
  chunkTKBRQY5C_cjs.CREATE_STORED_MCP_CLIENT_ROUTE,
  chunkTKBRQY5C_cjs.UPDATE_STORED_MCP_CLIENT_ROUTE,
  chunkTKBRQY5C_cjs.DELETE_STORED_MCP_CLIENT_ROUTE,
  // MCP Client Versions Routes
  // IMPORTANT: Routes with literal paths (e.g., /compare) must come BEFORE
  // routes with path parameters (e.g., /:versionId) to ensure correct matching.
  chunkDMAGP2MP_cjs.LIST_MCP_CLIENT_VERSIONS_ROUTE,
  chunkDMAGP2MP_cjs.CREATE_MCP_CLIENT_VERSION_ROUTE,
  chunkDMAGP2MP_cjs.COMPARE_MCP_CLIENT_VERSIONS_ROUTE,
  chunkDMAGP2MP_cjs.GET_MCP_CLIENT_VERSION_ROUTE,
  chunkDMAGP2MP_cjs.ACTIVATE_MCP_CLIENT_VERSION_ROUTE,
  chunkDMAGP2MP_cjs.RESTORE_MCP_CLIENT_VERSION_ROUTE,
  chunkDMAGP2MP_cjs.DELETE_MCP_CLIENT_VERSION_ROUTE
];

// src/server/server-adapter/routes/stored-prompt-blocks.ts
var STORED_PROMPT_BLOCKS_ROUTES = [
  // Stored Prompt Blocks CRUD Routes
  chunkW34IV6DV_cjs.LIST_STORED_PROMPT_BLOCKS_ROUTE,
  chunkW34IV6DV_cjs.GET_STORED_PROMPT_BLOCK_ROUTE,
  chunkW34IV6DV_cjs.CREATE_STORED_PROMPT_BLOCK_ROUTE,
  chunkW34IV6DV_cjs.UPDATE_STORED_PROMPT_BLOCK_ROUTE,
  chunkW34IV6DV_cjs.DELETE_STORED_PROMPT_BLOCK_ROUTE,
  // Prompt Block Versions Routes
  // IMPORTANT: Routes with literal paths (e.g., /compare) must come BEFORE
  // routes with path parameters (e.g., /:versionId) to ensure correct matching.
  chunkDK4A344H_cjs.LIST_PROMPT_BLOCK_VERSIONS_ROUTE,
  chunkDK4A344H_cjs.CREATE_PROMPT_BLOCK_VERSION_ROUTE,
  chunkDK4A344H_cjs.COMPARE_PROMPT_BLOCK_VERSIONS_ROUTE,
  chunkDK4A344H_cjs.GET_PROMPT_BLOCK_VERSION_ROUTE,
  chunkDK4A344H_cjs.ACTIVATE_PROMPT_BLOCK_VERSION_ROUTE,
  chunkDK4A344H_cjs.RESTORE_PROMPT_BLOCK_VERSION_ROUTE,
  chunkDK4A344H_cjs.DELETE_PROMPT_BLOCK_VERSION_ROUTE
];

// src/server/server-adapter/routes/stored-scorers.ts
var STORED_SCORERS_ROUTES = [
  // Stored Scorers CRUD Routes
  chunkC3U5LR4X_cjs.LIST_STORED_SCORERS_ROUTE,
  chunkC3U5LR4X_cjs.GET_STORED_SCORER_ROUTE,
  chunkC3U5LR4X_cjs.CREATE_STORED_SCORER_ROUTE,
  chunkC3U5LR4X_cjs.UPDATE_STORED_SCORER_ROUTE,
  chunkC3U5LR4X_cjs.DELETE_STORED_SCORER_ROUTE,
  // Scorer Versions Routes
  // IMPORTANT: Routes with literal paths (e.g., /compare) must come BEFORE
  // routes with path parameters (e.g., /:versionId) to ensure correct matching.
  chunkSI3B7F4U_cjs.LIST_SCORER_VERSIONS_ROUTE,
  chunkSI3B7F4U_cjs.CREATE_SCORER_VERSION_ROUTE,
  chunkSI3B7F4U_cjs.COMPARE_SCORER_VERSIONS_ROUTE,
  chunkSI3B7F4U_cjs.GET_SCORER_VERSION_ROUTE,
  chunkSI3B7F4U_cjs.ACTIVATE_SCORER_VERSION_ROUTE,
  chunkSI3B7F4U_cjs.RESTORE_SCORER_VERSION_ROUTE,
  chunkSI3B7F4U_cjs.DELETE_SCORER_VERSION_ROUTE
];

// src/server/server-adapter/routes/stored-skills.ts
var STORED_SKILLS_ROUTES = [
  // Stored Skills CRUD Routes
  chunkR2DKW2EK_cjs.LIST_STORED_SKILLS_ROUTE,
  chunkR2DKW2EK_cjs.GET_STORED_SKILL_ROUTE,
  chunkR2DKW2EK_cjs.CREATE_STORED_SKILL_ROUTE,
  chunkR2DKW2EK_cjs.UPDATE_STORED_SKILL_ROUTE,
  chunkR2DKW2EK_cjs.DELETE_STORED_SKILL_ROUTE,
  // Publish
  chunkR2DKW2EK_cjs.PUBLISH_STORED_SKILL_ROUTE
];

// src/server/server-adapter/routes/stored-workspaces.ts
var STORED_WORKSPACES_ROUTES = [
  // Stored Workspaces CRUD Routes
  chunkHERQV6YY_cjs.LIST_STORED_WORKSPACES_ROUTE,
  chunkHERQV6YY_cjs.GET_STORED_WORKSPACE_ROUTE,
  chunkHERQV6YY_cjs.CREATE_STORED_WORKSPACE_ROUTE,
  chunkHERQV6YY_cjs.UPDATE_STORED_WORKSPACE_ROUTE,
  chunkHERQV6YY_cjs.DELETE_STORED_WORKSPACE_ROUTE
];

// src/server/server-adapter/routes/system.ts
var SYSTEM_ROUTES = [chunkQQGEBRIG_cjs.GET_SYSTEM_PACKAGES_ROUTE];

// src/server/server-adapter/routes/tool-providers.ts
var TOOL_PROVIDER_ROUTES = [
  chunk6T2DK2GP_cjs.LIST_TOOL_PROVIDERS_ROUTE,
  chunk6T2DK2GP_cjs.LIST_TOOL_PROVIDER_TOOLKITS_ROUTE,
  chunk6T2DK2GP_cjs.LIST_TOOL_PROVIDER_TOOLS_ROUTE,
  chunk6T2DK2GP_cjs.GET_TOOL_PROVIDER_TOOL_SCHEMA_ROUTE
];

// src/server/server-adapter/routes/tools.ts
var TOOLS_ROUTES = [chunkLKBYAMJS_cjs.LIST_TOOLS_ROUTE, chunkLKBYAMJS_cjs.GET_TOOL_BY_ID_ROUTE, chunkLKBYAMJS_cjs.EXECUTE_TOOL_ROUTE];

// src/server/server-adapter/routes/vectors.ts
var VECTORS_ROUTES = [
  chunkCMGZD5UE_cjs.UPSERT_VECTORS_ROUTE,
  chunkCMGZD5UE_cjs.CREATE_INDEX_ROUTE,
  chunkCMGZD5UE_cjs.QUERY_VECTORS_ROUTE,
  chunkCMGZD5UE_cjs.LIST_INDEXES_ROUTE,
  chunkCMGZD5UE_cjs.DESCRIBE_INDEX_ROUTE,
  chunkCMGZD5UE_cjs.DELETE_INDEX_ROUTE,
  chunkCMGZD5UE_cjs.LIST_VECTORS_ROUTE,
  chunkCMGZD5UE_cjs.LIST_EMBEDDERS_ROUTE
];

// src/server/server-adapter/routes/workflows.ts
var WORKFLOWS_ROUTES = [
  chunkQOLNS6MT_cjs.LIST_WORKFLOWS_ROUTE,
  chunkQOLNS6MT_cjs.GET_WORKFLOW_BY_ID_ROUTE,
  chunkQOLNS6MT_cjs.LIST_WORKFLOW_RUNS_ROUTE,
  chunkQOLNS6MT_cjs.GET_WORKFLOW_RUN_BY_ID_ROUTE,
  chunkQOLNS6MT_cjs.DELETE_WORKFLOW_RUN_BY_ID_ROUTE,
  chunkQOLNS6MT_cjs.CREATE_WORKFLOW_RUN_ROUTE,
  chunkQOLNS6MT_cjs.STREAM_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESUME_STREAM_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.START_ASYNC_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.START_WORKFLOW_RUN_ROUTE,
  chunkQOLNS6MT_cjs.OBSERVE_STREAM_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESUME_ASYNC_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESUME_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.CANCEL_WORKFLOW_RUN_ROUTE,
  chunkQOLNS6MT_cjs.TIME_TRAVEL_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.TIME_TRAVEL_STREAM_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESTART_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESTART_ASYNC_WORKFLOW_ROUTE,
  chunkQOLNS6MT_cjs.RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE,
  chunkQOLNS6MT_cjs.RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE
];

// src/server/server-adapter/routes/workspace.ts
var WORKSPACE_ROUTES = [
  // List all workspaces route (at /api/workspaces)
  chunkHOAPZDJV_cjs.LIST_WORKSPACES_ROUTE,
  // Get workspace route (at /api/workspaces/:workspaceId)
  chunkHOAPZDJV_cjs.GET_WORKSPACE_ROUTE,
  // Filesystem routes (at /api/workspaces/:workspaceId/fs/*)
  ...chunkHOAPZDJV_cjs.WORKSPACE_FS_ROUTES,
  // Search routes (at /api/workspaces/:workspaceId/search, /api/workspaces/:workspaceId/index)
  ...chunkHOAPZDJV_cjs.WORKSPACE_SEARCH_ROUTES,
  // Skills routes (search must come before parameterized routes)
  ...chunkHOAPZDJV_cjs.WORKSPACE_SKILLS_ROUTES,
  // skills.sh proxy routes (at /api/workspaces/:workspaceId/skills-sh/*)
  ...chunkHOAPZDJV_cjs.WORKSPACE_SKILLS_SH_ROUTES
];

// src/server/server-adapter/routes/permissions.ts
var METHOD_TO_ACTION = {
  GET: "read",
  POST: "write",
  // Default for POST, may be overridden to 'execute'
  PUT: "write",
  PATCH: "write",
  DELETE: "delete"
};
var EXECUTE_PATTERNS = [
  "/generate",
  "/stream",
  "/execute",
  "/start",
  "/resume",
  "/restart",
  "/cancel",
  "/approve",
  "/decline",
  "/speak",
  "/listen",
  "/query",
  "/search",
  "/observe",
  "/time-travel",
  "/enhance",
  "/clone"
];
function extractResource(path) {
  const segments = path.replace(/^\//, "").split("/");
  if (segments.length === 0) {
    return null;
  }
  const firstSegment = segments[0];
  if (firstSegment === "stored" && segments[1] === "agents") {
    return "stored-agents";
  }
  if (firstSegment === ".well-known") {
    return "a2a";
  }
  return firstSegment || null;
}
function deriveAction(method, path) {
  const upperMethod = method.toUpperCase();
  if (upperMethod === "POST") {
    const isExecuteOperation = EXECUTE_PATTERNS.some((pattern) => path.includes(pattern));
    return isExecuteOperation ? "execute" : "write";
  }
  return METHOD_TO_ACTION[upperMethod] || "read";
}
function derivePermission(route) {
  if (route.method === "ALL") {
    return null;
  }
  const resource = extractResource(route.path);
  if (!resource) {
    return null;
  }
  const action = deriveAction(route.method, route.path);
  return `${resource}:${action}`;
}
function getEffectivePermission(route) {
  if (route.requiresAuth === false) {
    return null;
  }
  if (route.requiresPermission) {
    return route.requiresPermission;
  }
  return derivePermission(route);
}

// src/server/server-adapter/routes/index.ts
var SERVER_ROUTES = [
  ...AGENTS_ROUTES,
  ...chunkLTJHINYX_cjs.AUTH_ROUTES,
  ...WORKFLOWS_ROUTES,
  ...TOOLS_ROUTES,
  ...PROCESSORS_ROUTES,
  ...MEMORY_ROUTES,
  ...SCORES_ROUTES,
  ...OBSERVABILITY_ROUTES,
  ...LOGS_ROUTES,
  ...VECTORS_ROUTES,
  ...A2A_ROUTES,
  ...AGENT_BUILDER_ROUTES,
  ...WORKSPACE_ROUTES,
  ...LEGACY_ROUTES,
  ...MCP_ROUTES,
  ...STORED_AGENTS_ROUTES,
  ...STORED_MCP_CLIENTS_ROUTES,
  ...STORED_PROMPT_BLOCKS_ROUTES,
  ...STORED_SCORERS_ROUTES,
  ...STORED_WORKSPACES_ROUTES,
  ...STORED_SKILLS_ROUTES,
  ...TOOL_PROVIDER_ROUTES,
  ...PROCESSOR_PROVIDER_ROUTES,
  ...SYSTEM_ROUTES,
  ...DATASETS_ROUTES
];

// src/server/server-adapter/redact.ts
function redactV2Payload(payload) {
  const redactedPayload = { ...payload };
  if (redactedPayload.metadata && typeof redactedPayload.metadata === "object") {
    const { request, ...metadataRest } = redactedPayload.metadata;
    redactedPayload.metadata = metadataRest;
  }
  if (redactedPayload.output && typeof redactedPayload.output === "object") {
    const output = { ...redactedPayload.output };
    if (Array.isArray(output.steps)) {
      output.steps = output.steps.map((step) => {
        if (step && typeof step === "object") {
          const { request, ...stepRest } = step;
          return stepRest;
        }
        return step;
      });
    }
    redactedPayload.output = output;
  }
  return redactedPayload;
}
function redactStreamChunk(chunk) {
  if (!chunk || typeof chunk !== "object") {
    return chunk;
  }
  const typedChunk = chunk;
  switch (chunk.type) {
    case "step-start": {
      if ("payload" in typedChunk && typedChunk.payload && typeof typedChunk.payload === "object") {
        const { payload, ...rest } = typedChunk;
        const { request, ...payloadRest } = payload;
        return {
          ...rest,
          type: "step-start",
          payload: {
            ...payloadRest,
            // Keep an empty request object to maintain structure but remove body
            request: {}
          }
        };
      } else if ("request" in typedChunk) {
        const { request, ...rest } = typedChunk;
        return {
          ...rest,
          type: "step-start",
          // Keep an empty request object to maintain structure
          request: {}
        };
      }
      return chunk;
    }
    case "step-finish": {
      if ("payload" in typedChunk && typedChunk.payload && typeof typedChunk.payload === "object") {
        const { payload, ...rest } = typedChunk;
        return {
          ...rest,
          type: "step-finish",
          payload: redactV2Payload(payload)
        };
      } else if ("request" in typedChunk) {
        const { request, ...rest } = typedChunk;
        return {
          ...rest,
          type: "step-finish"
        };
      }
      return chunk;
    }
    case "finish": {
      if ("payload" in typedChunk && typedChunk.payload && typeof typedChunk.payload === "object") {
        const { payload, ...rest } = typedChunk;
        return {
          ...rest,
          type: "finish",
          payload: redactV2Payload(payload)
        };
      } else if ("request" in typedChunk) {
        const { request, ...rest } = typedChunk;
        return {
          ...rest,
          type: "finish"
        };
      }
      return chunk;
    }
    default:
      return chunk;
  }
}

// src/server/server-adapter/index.ts
function getSchemaTypeName(schema) {
  const schemaDef = schema?._def ?? schema?.def;
  return schemaDef?.typeName ?? schemaDef?.type;
}
function unwrapOptionalNullable(schema) {
  let inner = schema;
  let typeName = getSchemaTypeName(inner);
  while (typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "optional" || typeName === "nullable") {
    const innerDef = inner?._def ?? inner?.def;
    if (!innerDef?.innerType) {
      return inner;
    }
    inner = innerDef.innerType;
    typeName = getSchemaTypeName(inner);
  }
  return inner;
}
function parseComplexQueryParams(queryParamSchema, params) {
  if (!(queryParamSchema instanceof v4.z.ZodObject)) {
    return params;
  }
  const parsedParams = { ...params };
  const shape = queryParamSchema.shape;
  for (const [key, fieldSchema] of Object.entries(shape)) {
    const rawValue = parsedParams[key];
    if (typeof rawValue !== "string") {
      continue;
    }
    const unwrappedField = unwrapOptionalNullable(fieldSchema);
    const typeName = getSchemaTypeName(unwrappedField);
    const isComplex = typeName === "ZodObject" || typeName === "ZodArray" || typeName === "ZodRecord" || typeName === "object" || typeName === "array" || typeName === "record";
    if (!isComplex) {
      continue;
    }
    try {
      parsedParams[key] = JSON.parse(rawValue);
    } catch {
    }
  }
  return parsedParams;
}
function normalizeQueryParams(rawQuery) {
  const queryParams = {};
  const bracketGroups = {};
  for (const [key, value] of Object.entries(rawQuery)) {
    const bracketMatch = key.match(/^([^[]+)\[([^\]]+)\]$/);
    if (bracketMatch) {
      const parent = bracketMatch[1];
      const child = bracketMatch[2];
      const strValue = Array.isArray(value) ? value.filter((v) => typeof v === "string")[0] : typeof value === "string" ? value : void 0;
      if (strValue !== void 0) {
        if (!bracketGroups[parent]) {
          bracketGroups[parent] = {};
        }
        bracketGroups[parent][child] = strValue;
      }
    } else if (typeof value === "string") {
      queryParams[key] = value;
    } else if (Array.isArray(value)) {
      const stringValues = value.filter((v) => typeof v === "string");
      queryParams[key] = stringValues.length === 1 ? stringValues[0] : stringValues;
    }
  }
  for (const [parent, children] of Object.entries(bracketGroups)) {
    if (!(parent in queryParams)) {
      queryParams[parent] = JSON.stringify(children);
    }
  }
  return queryParams;
}
var MastraServer = class _MastraServer extends server.MastraServerBase {
  mastra;
  bodyLimitOptions;
  tools;
  prefix;
  openapiPath;
  taskStore;
  customRouteAuthConfig;
  streamOptions;
  httpLoggingConfig;
  customApiRoutes;
  mcpOptions;
  customRouteHandler = null;
  constructor({
    app,
    mastra,
    bodyLimitOptions,
    tools,
    prefix = "/api",
    openapiPath = "",
    taskStore,
    customRouteAuthConfig,
    streamOptions,
    customApiRoutes,
    mcpOptions
  }) {
    super({ app, name: "MastraServer" });
    this.mastra = mastra;
    this.bodyLimitOptions = bodyLimitOptions;
    this.tools = tools;
    this.prefix = chunkEFX5WYRT_cjs.normalizeRoutePath(prefix);
    this.openapiPath = openapiPath;
    this.taskStore = taskStore;
    this.customRouteAuthConfig = customRouteAuthConfig;
    this.streamOptions = { redact: true, ...streamOptions };
    this.customApiRoutes = customApiRoutes;
    this.mcpOptions = mcpOptions;
    const serverConfig = mastra.getServer();
    this.httpLoggingConfig = this.parseLoggingConfig(serverConfig?.build?.apiReqLogs);
    mastra.setMastraServer(this);
  }
  /**
   * Parses the apiReqLogs configuration into a normalized HttpLoggingConfig.
   * @param config - The raw config value from server.build.apiReqLogs
   * @returns Normalized HttpLoggingConfig or undefined if disabled
   */
  parseLoggingConfig(config) {
    if (config === true) {
      return {
        enabled: true,
        level: "info",
        redactHeaders: ["authorization", "cookie"]
      };
    }
    if (typeof config === "object" && config.enabled) {
      return {
        enabled: true,
        level: config.level || "info",
        excludePaths: config.excludePaths,
        includeHeaders: config.includeHeaders,
        includeQueryParams: config.includeQueryParams,
        redactHeaders: [.../* @__PURE__ */ new Set([...["authorization", "cookie"], ...config.redactHeaders || []])]
      };
    }
    return void 0;
  }
  /**
   * Determines if a request to the given path should be logged.
   * @param path - The request path to check
   * @returns true if the request should be logged, false otherwise
   */
  shouldLogRequest(path) {
    if (!this.httpLoggingConfig?.enabled) {
      return false;
    }
    const excludePaths = this.httpLoggingConfig.excludePaths || [];
    return !excludePaths.some((excluded) => path === excluded || path.startsWith(excluded + "/"));
  }
  mergeRequestContext({
    paramsRequestContext,
    bodyRequestContext
  }) {
    const requestContext$1 = new requestContext.RequestContext();
    if (bodyRequestContext) {
      for (const [key, value] of Object.entries(bodyRequestContext)) {
        requestContext$1.set(key, value);
      }
    }
    if (paramsRequestContext) {
      for (const [key, value] of Object.entries(paramsRequestContext)) {
        requestContext$1.set(key, value);
      }
    }
    return requestContext$1;
  }
  /**
   * Check if the current request should be authenticated/authorized.
   * Returns null if auth passes, or an error response if it fails.
   *
   * This is a thin wrapper around coreAuthMiddleware that:
   * 1. Handles route-level requiresAuth opt-out (not available in global middleware)
   * 2. Delegates all other auth logic to coreAuthMiddleware
   * 3. Translates the AuthResult into the {status, error} format adapters expect
   */
  async checkRouteAuth(route, context) {
    const authConfig = this.mastra.getServer()?.auth;
    if (!authConfig) {
      return null;
    }
    if (route.requiresAuth === false) {
      return null;
    }
    const authHeader = context.getHeader("authorization");
    let token = authHeader ? authHeader.replace("Bearer ", "") : null;
    if (!token) {
      token = context.getQuery("apiKey") || null;
    }
    const result = await chunkQVMLEJ63_cjs.coreAuthMiddleware({
      path: context.path,
      method: context.method,
      getHeader: context.getHeader,
      mastra: this.mastra,
      authConfig,
      customRouteAuthConfig: this.customRouteAuthConfig,
      requestContext: context.requestContext,
      rawRequest: context.request,
      token,
      buildAuthorizeContext: context.buildAuthorizeContext ?? (() => null)
    });
    if (result.action === "next") {
      return null;
    }
    const errorBody = result.body;
    return { status: result.status, error: errorBody?.error ?? "Access denied" };
  }
  /**
   * Check if the user has the required permission for a route.
   *
   * Uses convention-based permission derivation:
   * 1. If route has explicit `requiresPermission`, use that
   * 2. Otherwise, derive permission from path/method (e.g., GET /agents → agents:read)
   * 3. Routes with `requiresAuth: false` skip permission checks
   *
   * @param route - The route being accessed
   * @param userPermissions - The user's permissions from the request context
   * @returns Error response if permission denied, null if allowed
   */
  checkRoutePermission(route, userPermissions, hasPermissionFn) {
    const rbacProvider = this.mastra.getServer()?.rbac;
    if (!rbacProvider) {
      return null;
    }
    const requiredPermission = getEffectivePermission(route);
    if (!requiredPermission) {
      return null;
    }
    if (!userPermissions || !hasPermissionFn(userPermissions, requiredPermission)) {
      return {
        status: 403,
        error: "Forbidden",
        message: `Missing required permission: ${requiredPermission}`
      };
    }
    return null;
  }
  async init() {
    this.registerContextMiddleware();
    this.registerAuthMiddleware();
    this.registerHttpLoggingMiddleware();
    await this.validateEELicense();
    await this.registerCustomApiRoutes();
    await this.registerRoutes();
  }
  /**
   * Validate that EE features have a valid license in production.
   * Throws if RBAC is configured without a valid license outside dev/test environments.
   */
  async validateEELicense() {
    const rbacProvider = this.mastra.getServer()?.rbac;
    if (!rbacProvider) return;
    try {
      const { isEEEnabled } = await import('@mastra/core/auth/ee');
      if (!isEEEnabled()) {
        throw new Error(
          "[mastra/auth-ee] RBAC is configured but no valid EE license was found.\nRBAC requires a Mastra Enterprise License for production use.\nSet the MASTRA_EE_LICENSE environment variable with your license key.\nLearn more: https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE"
        );
      }
    } catch (err) {
      if (err instanceof Error && err.message.startsWith("[mastra/auth-ee]")) {
        throw err;
      }
      throw new Error(
        "[mastra/auth-ee] RBAC is configured but the EE module (@mastra/core/auth/ee) could not be loaded.\nEnsure @mastra/core is updated to a version that includes EE support."
      );
    }
  }
  /**
   * Override in adapters to register custom API routes defined via registerApiRoute().
   * Called by init() between registerAuthMiddleware() and registerRoutes().
   */
  async registerCustomApiRoutes() {
  }
  /**
   * Creates an internal Hono sub-app with all custom API routes registered.
   * Stores the handler on this instance for use by handleCustomRouteRequest().
   * Returns true if custom routes were found and registered.
   */
  async buildCustomRouteHandler() {
    const routes = this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes;
    if (!routes || routes.length === 0) return false;
    const NOT_FOUND_HEADER = "x-mastra-custom-route-not-found";
    const mastra = this.mastra;
    const app = new hono.Hono();
    app.use("*", async (c, next) => {
      c.set("mastra", mastra);
      c.set("requestContext", c.env?.requestContext ?? new requestContext.RequestContext());
      await next();
    });
    for (const route of routes) {
      const handler = "handler" in route && route.handler ? route.handler : "createHandler" in route ? await route.createHandler({ mastra }) : void 0;
      if (!handler) continue;
      const middlewares = [];
      if (route.middleware) {
        middlewares.push(...Array.isArray(route.middleware) ? route.middleware : [route.middleware]);
      }
      const allHandlers = [...middlewares, handler];
      if (route.method === "ALL") {
        app.all(route.path, allHandlers[0], ...allHandlers.slice(1));
      } else {
        app.on(route.method, route.path, allHandlers[0], ...allHandlers.slice(1));
      }
    }
    app.notFound(() => new Response(null, { status: 404, headers: { [NOT_FOUND_HEADER]: "true" } }));
    this.customRouteHandler = async (request, env) => app.fetch(request, env);
    return true;
  }
  /**
   * Forwards a request to the internal custom route handler.
   * Returns the Response if a custom route matched, or null to fall through.
   * Used by non-Hono adapter bridges.
   */
  async handleCustomRouteRequest(url, method, headers, body, requestContext) {
    if (!this.customRouteHandler) return null;
    const fetchHeaders = new Headers();
    for (const [key, value] of Object.entries(headers)) {
      if (typeof value === "string") fetchHeaders.set(key, value);
      else if (Array.isArray(value))
        value.forEach((v) => {
          fetchHeaders.append(key, v);
        });
    }
    const init = { method, headers: fetchHeaders };
    if (["POST", "PUT", "PATCH"].includes(method) && body !== void 0) {
      const contentType = (typeof headers["content-type"] === "string" ? headers["content-type"] : "") || "";
      if (contentType.includes("application/json")) {
        init.body = JSON.stringify(body);
      } else if (typeof body === "string") {
        init.body = body;
      } else if (body instanceof ArrayBuffer || body instanceof Uint8Array || body instanceof ReadableStream) {
        init.body = body;
      }
    }
    const request = new globalThis.Request(url, init);
    const response = await this.customRouteHandler(request, { requestContext });
    if (response.headers.get("x-mastra-custom-route-not-found") === "true") return null;
    return response;
  }
  /**
   * Pipes a custom route Response to a Node.js ServerResponse (http.ServerResponse).
   * Works with Koa (ctx.res), Express (res), and Fastify (reply.raw).
   */
  async writeCustomRouteResponse(response, nodeRes) {
    const headers = {};
    response.headers.forEach((value, key) => {
      if (key.toLowerCase() !== "set-cookie") {
        headers[key] = value;
      }
    });
    const setCookies = response.headers.getSetCookie?.();
    if (setCookies && setCookies.length > 0) {
      headers["set-cookie"] = setCookies;
    }
    nodeRes.writeHead(response.status, headers);
    if (response.body) {
      const reader = response.body.getReader();
      try {
        while (true) {
          const { done, value } = await reader.read();
          if (done) break;
          nodeRes.write(value);
        }
      } finally {
        nodeRes.end();
      }
    } else {
      nodeRes.end(await response.text());
    }
  }
  /**
   * Builds the OpenAPI spec object with servers field and custom route paths.
   */
  buildOpenAPISpec(config, prefix) {
    const openApiSpec = chunk6P7P7Y5U_cjs.generateOpenAPIDocument(SERVER_ROUTES, config);
    if (prefix) {
      openApiSpec.servers = [{ url: prefix }];
    }
    const allCustomRoutes = this.customApiRoutes ?? this.mastra.getServer()?.apiRoutes;
    if (allCustomRoutes && allCustomRoutes.length > 0) {
      const customPaths = chunk6P7P7Y5U_cjs.convertCustomRoutesToOpenAPIPaths(allCustomRoutes);
      if (prefix) {
        for (const pathKey of Object.keys(customPaths)) {
          if (!customPaths[pathKey].servers) {
            customPaths[pathKey].servers = [{ url: "/" }];
          }
        }
      }
      openApiSpec.paths = { ...openApiSpec.paths, ...customPaths };
    }
    return openApiSpec;
  }
  async registerOpenAPIRoute(app, config = {}, { prefix }) {
    const {
      title = "Mastra API",
      version = "1.0.0",
      description = "Mastra Server API",
      path = "/openapi.json"
    } = config;
    const openApiSpec = this.buildOpenAPISpec({ title, version, description }, prefix);
    const openApiRoute = {
      method: "GET",
      path,
      responseType: "json",
      handler: async () => openApiSpec
    };
    await this.registerRoute(app, openApiRoute, { prefix });
  }
  async registerRoutes() {
    for (const route of SERVER_ROUTES) {
      await this.registerRoute(this.app, route, { prefix: this.prefix });
    }
    if (this.openapiPath) {
      const specConfig = {
        title: "Mastra API",
        version: "1.0.0",
        description: "Mastra Server API"
      };
      await this.registerOpenAPIRoute(this.app, { ...specConfig, path: this.openapiPath }, { prefix: this.prefix });
    }
  }
  async parsePathParams(route, params) {
    const pathParamSchema = route.pathParamSchema;
    if (!pathParamSchema) {
      return params;
    }
    return pathParamSchema.parseAsync(params);
  }
  async parseQueryParams(route, params) {
    const queryParamSchema = route.queryParamSchema;
    if (!queryParamSchema) {
      return params;
    }
    const normalizedParams = parseComplexQueryParams(queryParamSchema, params);
    return queryParamSchema.parseAsync(normalizedParams);
  }
  async parseBody(route, body) {
    const bodySchema = route.bodySchema;
    if (!bodySchema) {
      return body;
    }
    return bodySchema.parseAsync(body);
  }
  static CONTEXT_LABELS = {
    query: "query parameters",
    body: "request body",
    path: "path parameters"
  };
  resolveValidationError(route, error, context) {
    const hook = route.onValidationError ?? this.mastra.getServer()?.onValidationError;
    if (hook) {
      try {
        const result = hook(error, context);
        if (result) {
          return result;
        }
      } catch (hookError) {
        this.mastra.getLogger()?.error("Error in custom onValidationError hook", {
          error: hookError instanceof Error ? { message: hookError.message, stack: hookError.stack } : hookError
        });
      }
    }
    return {
      status: 400,
      body: chunkY2BKW5ND_cjs.formatZodError(error, _MastraServer.CONTEXT_LABELS[context])
    };
  }
};

Object.defineProperty(exports, "WorkflowRegistry", {
  enumerable: true,
  get: function () { return chunkEFX5WYRT_cjs.WorkflowRegistry; }
});
Object.defineProperty(exports, "normalizeRoutePath", {
  enumerable: true,
  get: function () { return chunkEFX5WYRT_cjs.normalizeRoutePath; }
});
Object.defineProperty(exports, "createPublicRoute", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.createPublicRoute; }
});
Object.defineProperty(exports, "createRoute", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.createRoute; }
});
Object.defineProperty(exports, "generateOpenAPIDocument", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.generateOpenAPIDocument; }
});
Object.defineProperty(exports, "jsonQueryParam", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.jsonQueryParam; }
});
Object.defineProperty(exports, "pickParams", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.pickParams; }
});
Object.defineProperty(exports, "wrapSchemaForQueryParams", {
  enumerable: true,
  get: function () { return chunk6P7P7Y5U_cjs.wrapSchemaForQueryParams; }
});
exports.MastraServer = MastraServer;
exports.SERVER_ROUTES = SERVER_ROUTES;
exports.deriveAction = deriveAction;
exports.derivePermission = derivePermission;
exports.extractResource = extractResource;
exports.getEffectivePermission = getEffectivePermission;
exports.normalizeQueryParams = normalizeQueryParams;
exports.redactStreamChunk = redactStreamChunk;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map