@dexto/server 1.6.19 → 1.6.21

package/dist/hono/routes/mcp.cjs

@@ -34,7 +34,7 @@ const McpServerUpdateSchema = import_zod_openapi.z.object({
   config: import_core.McpServerConfigSchema.describe("The updated server configuration object"),
   persistToAgent: import_zod_openapi.z.boolean().optional().describe("If true, saves the server to agent configuration file")
 }).strict().describe("Request body for updating an MCP server");
-const ExecuteToolBodySchema = import_zod_openapi.z.record(import_zod_openapi.z.unknown()).describe(
+const ExecuteToolBodySchema = import_responses.JsonObjectSchema.describe(
   "Tool execution parameters as JSON object. The specific fields depend on the tool being executed and are defined by the tool's inputSchema."
 );
 const ServerStatusResponseSchema = import_zod_openapi.z.object({
@@ -49,23 +49,14 @@ const ServerInfoSchema = import_zod_openapi.z.object({
 const ServersListResponseSchema = import_zod_openapi.z.object({
   servers: import_zod_openapi.z.array(ServerInfoSchema).describe("Array of server information")
 }).strict().describe("List of MCP servers");
-const JsonSchemaProperty = import_zod_openapi.z.object({
-  type: import_zod_openapi.z.enum(["string", "number", "integer", "boolean", "object", "array"]).optional().describe("Property type"),
-  description: import_zod_openapi.z.string().optional().describe("Property description"),
-  enum: import_zod_openapi.z.array(import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.number(), import_zod_openapi.z.boolean()])).optional().describe("Enum values"),
-  default: import_zod_openapi.z.any().optional().describe("Default value")
-}).passthrough().describe("JSON Schema property definition");
-const ToolInputSchema = import_zod_openapi.z.object({
-  type: import_zod_openapi.z.literal("object").optional().describe('Schema type, always "object" when present'),
-  properties: import_zod_openapi.z.record(JsonSchemaProperty).optional().describe("Property definitions"),
-  required: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Required property names")
-}).passthrough().describe("JSON Schema for tool input parameters");
 const ToolInfoSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Tool identifier"),
   name: import_zod_openapi.z.string().describe("Tool name"),
   description: import_zod_openapi.z.string().describe("Tool description"),
-  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters"),
-  _meta: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional tool metadata (e.g., MCP Apps UI resource info)")
+  inputSchema: import_responses.ToolInputSchema.optional().describe("JSON Schema for tool input parameters"),
+  _meta: import_responses.JsonObjectSchema.optional().describe(
+    "Optional tool metadata (e.g., MCP Apps UI resource info)"
+  )
 }).strict().describe("Tool information");
 const ToolsListResponseSchema = import_zod_openapi.z.object({
   tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of available tools")
@@ -80,198 +71,234 @@ const RestartResponseSchema = import_zod_openapi.z.object({
 }).strict().describe("Server restart response");
 const ToolExecutionResponseSchema = import_zod_openapi.z.object({
   success: import_zod_openapi.z.boolean().describe("Whether tool execution succeeded"),
-  data: import_zod_openapi.z.any().optional().describe("Tool execution result data"),
+  data: import_responses.JsonValueSchema.optional().describe("Tool execution result data"),
   error: import_zod_openapi.z.string().optional().describe("Error message if execution failed")
 }).strict().describe("Tool execution response");
 const ServerConfigResponseSchema = import_zod_openapi.z.object({
   name: import_zod_openapi.z.string().describe("Server name"),
   config: import_core.McpServerConfigSchema.describe("Server configuration")
 }).strict().describe("MCP server configuration response");
+const ServerResourceSchema = import_zod_openapi.z.object({
+  uri: import_zod_openapi.z.string().describe("Resolved resource URI for this server"),
+  name: import_zod_openapi.z.string().describe("Resource display name"),
+  originalUri: import_zod_openapi.z.string().describe("Original MCP resource URI"),
+  serverName: import_zod_openapi.z.string().describe("Owning MCP server name")
+}).strict().describe("Resource exposed by a specific MCP server");
 const ResourcesListResponseSchema = import_zod_openapi.z.object({
   success: import_zod_openapi.z.boolean().describe("Success indicator"),
-  resources: import_zod_openapi.z.array(import_responses.ResourceSchema).describe("Array of available resources")
+  resources: import_zod_openapi.z.array(ServerResourceSchema).describe("Array of available resources")
 }).strict().describe("List of resources from MCP server");
 const ResourceContentSchema = import_zod_openapi.z.object({
-  content: import_zod_openapi.z.any().describe("Resource content data")
+  content: import_responses.JsonValueSchema.describe("Resource content data")
 }).strict().describe("Resource content wrapper");
 const ResourceContentResponseSchema = import_zod_openapi.z.object({
   success: import_zod_openapi.z.boolean().describe("Success indicator"),
   data: ResourceContentSchema.describe("Resource content")
 }).strict().describe("Resource content response");
-function createMcpRouter(getAgent, getAgentConfigPath) {
-  const app = new import_zod_openapi.OpenAPIHono();
-  const addServerRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/mcp/servers",
-    summary: "Add MCP Server",
-    description: "Connects a new MCP server dynamically",
-    tags: ["mcp"],
-    request: { body: { content: { "application/json": { schema: McpServerRequestSchema } } } },
-    responses: {
-      200: {
-        description: "Server connected",
-        content: { "application/json": { schema: ServerStatusResponseSchema } }
-      }
-    }
-  });
-  const listServersRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/mcp/servers",
-    summary: "List MCP Servers",
-    description: "Gets a list of all connected and failed MCP servers",
-    tags: ["mcp"],
-    responses: {
-      200: {
-        description: "Servers list",
-        content: { "application/json": { schema: ServersListResponseSchema } }
-      }
-    }
-  });
-  const getServerConfigRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/mcp/servers/{serverId}/config",
-    summary: "Get MCP Server Config",
-    description: "Retrieves the configuration for a specific MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+function mountMcpSubrouter(app, router) {
+  app.route("/", router);
+}
+const addServerRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/mcp/servers",
+  summary: "Add MCP Server",
+  description: "Connects a new MCP server dynamically",
+  tags: ["mcp"],
+  request: { body: { content: { "application/json": { schema: McpServerRequestSchema } } } },
+  responses: {
+    200: {
+      description: "Server connected",
+      content: { "application/json": { schema: ServerStatusResponseSchema } }
+    },
+    400: import_responses.BadRequestErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+const listServersRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/mcp/servers",
+  summary: "List MCP Servers",
+  description: "Gets a list of all connected and failed MCP servers",
+  tags: ["mcp"],
+  responses: {
+    200: {
+      description: "Servers list",
+      content: { "application/json": { schema: ServersListResponseSchema } }
+    },
+    500: import_responses.InternalErrorResponse
+  }
+});
+const getServerConfigRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/mcp/servers/{serverId}/config",
+  summary: "Get MCP Server Config",
+  description: "Retrieves the configuration for a specific MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  },
+  responses: {
+    200: {
+      description: "Server configuration",
+      content: { "application/json": { schema: ServerConfigResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Server configuration",
-        content: { "application/json": { schema: ServerConfigResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const updateServerRoute = (0, import_zod_openapi.createRoute)({
-    method: "put",
-    path: "/mcp/servers/{serverId}",
-    summary: "Update MCP Server",
-    description: "Updates configuration for an existing MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") }),
-      body: { content: { "application/json": { schema: McpServerUpdateSchema } } }
+  }
+});
+const updateServerRoute = (0, import_zod_openapi.createRoute)({
+  method: "put",
+  path: "/mcp/servers/{serverId}",
+  summary: "Update MCP Server",
+  description: "Updates configuration for an existing MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") }),
+    body: { content: { "application/json": { schema: McpServerUpdateSchema } } }
+  },
+  responses: {
+    200: {
+      description: "Server updated",
+      content: { "application/json": { schema: ServerStatusResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Server updated",
-        content: { "application/json": { schema: ServerStatusResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const toolsRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/mcp/servers/{serverId}/tools",
-    summary: "List Server Tools",
-    description: "Retrieves the list of tools available on a specific MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  }
+});
+const toolsRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/mcp/servers/{serverId}/tools",
+  summary: "List Server Tools",
+  description: "Retrieves the list of tools available on a specific MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  },
+  responses: {
+    200: {
+      description: "Tools list",
+      content: { "application/json": { schema: ToolsListResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Tools list",
-        content: { "application/json": { schema: ToolsListResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const deleteServerRoute = (0, import_zod_openapi.createRoute)({
-    method: "delete",
-    path: "/mcp/servers/{serverId}",
-    summary: "Remove MCP Server",
-    description: "Disconnects and removes an MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  }
+});
+const deleteServerRoute = (0, import_zod_openapi.createRoute)({
+  method: "delete",
+  path: "/mcp/servers/{serverId}",
+  summary: "Remove MCP Server",
+  description: "Disconnects and removes an MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  },
+  responses: {
+    200: {
+      description: "Disconnected",
+      content: { "application/json": { schema: DisconnectResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Disconnected",
-        content: { "application/json": { schema: DisconnectResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const restartServerRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/mcp/servers/{serverId}/restart",
-    summary: "Restart MCP Server",
-    description: "Restarts a connected MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  }
+});
+const restartServerRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/mcp/servers/{serverId}/restart",
+  summary: "Restart MCP Server",
+  description: "Restarts a connected MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  },
+  responses: {
+    200: {
+      description: "Server restarted",
+      content: { "application/json": { schema: RestartResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Server restarted",
-        content: { "application/json": { schema: RestartResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const execToolRoute = (0, import_zod_openapi.createRoute)({
-    method: "post",
-    path: "/mcp/servers/{serverId}/tools/{toolName}/execute",
-    summary: "Execute MCP Tool",
-    description: "Executes a tool on an MCP server directly",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({
-        serverId: import_zod_openapi.z.string().describe("The ID of the MCP server"),
-        toolName: import_zod_openapi.z.string().describe("The name of the tool to execute")
-      }),
-      body: { content: { "application/json": { schema: ExecuteToolBodySchema } } }
+  }
+});
+const execToolRoute = (0, import_zod_openapi.createRoute)({
+  method: "post",
+  path: "/mcp/servers/{serverId}/tools/{toolName}/execute",
+  summary: "Execute MCP Tool",
+  description: "Executes a tool on an MCP server directly",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({
+      serverId: import_zod_openapi.z.string().describe("The ID of the MCP server"),
+      toolName: import_zod_openapi.z.string().describe("The name of the tool to execute")
+    }),
+    body: { content: { "application/json": { schema: ExecuteToolBodySchema } } }
+  },
+  responses: {
+    200: {
+      description: "Tool executed",
+      content: { "application/json": { schema: ToolExecutionResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Tool executed",
-        content: { "application/json": { schema: ToolExecutionResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const listResourcesRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/mcp/servers/{serverId}/resources",
-    summary: "List Server Resources",
-    description: "Retrieves all resources available from a specific MCP server",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  }
+});
+const listResourcesRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/mcp/servers/{serverId}/resources",
+  summary: "List Server Resources",
+  description: "Retrieves all resources available from a specific MCP server",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+  },
+  responses: {
+    200: {
+      description: "Server resources",
+      content: { "application/json": { schema: ResourcesListResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Server resources",
-        content: { "application/json": { schema: ResourcesListResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  const getResourceContentRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/mcp/servers/{serverId}/resources/{resourceId}/content",
-    summary: "Read Server Resource Content",
-    description: "Reads content from a specific resource on an MCP server. This endpoint automatically constructs the qualified URI format (mcp:serverId:resourceId)",
-    tags: ["mcp"],
-    request: {
-      params: import_zod_openapi.z.object({
-        serverId: import_zod_openapi.z.string().describe("The ID of the MCP server"),
-        resourceId: import_zod_openapi.z.string().min(1, "Resource ID is required").transform((encoded) => decodeURIComponent(encoded)).describe("The URI-encoded resource identifier on that server")
-      })
+  }
+});
+const getResourceContentRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/mcp/servers/{serverId}/resources/{resourceId}/content",
+  summary: "Read Server Resource Content",
+  description: "Reads content from a specific resource on an MCP server. This endpoint automatically constructs the qualified URI format (mcp:serverId:resourceId)",
+  tags: ["mcp"],
+  request: {
+    params: import_zod_openapi.z.object({
+      serverId: import_zod_openapi.z.string().describe("The ID of the MCP server"),
+      resourceId: import_zod_openapi.z.string().min(1, "Resource ID is required").transform((encoded) => decodeURIComponent(encoded)).describe("The URI-encoded resource identifier on that server")
+    })
+  },
+  responses: {
+    200: {
+      description: "Resource content",
+      content: { "application/json": { schema: ResourceContentResponseSchema } }
     },
-    responses: {
-      200: {
-        description: "Resource content",
-        content: { "application/json": { schema: ResourceContentResponseSchema } }
-      },
-      404: { description: "Not found" }
+    404: {
+      description: "Not found",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
     }
-  });
-  return app.openapi(addServerRoute, async (ctx) => {
+  }
+});
+function createMcpRouter(getAgent, getAgentConfigPath) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const serverRegistrationRouter = new import_zod_openapi.OpenAPIHono().openapi(addServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { name, config, persistToAgent } = ctx.req.valid("json");
     await agent.addMcpServer(name, config);
@@ -317,22 +344,23 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     for (const name of Object.keys(failedConnections)) {
       servers.push({ id: name, name, status: "error" });
     }
-    return ctx.json({ servers });
+    return ctx.json({ servers }, 200);
   }).openapi(getServerConfigRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const config = agent.getMcpServerConfig(serverId);
     if (!config) {
-      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
-    return ctx.json({ name: serverId, config }, 200);
-  }).openapi(updateServerRoute, async (ctx) => {
+    return ctx.json({ name: serverId, config: import_core.McpServerConfigSchema.parse(config) }, 200);
+  });
+  const serverUpdateRouter = new import_zod_openapi.OpenAPIHono().openapi(updateServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const { config, persistToAgent } = ctx.req.valid("json");
     const existingConfig = agent.getMcpServerConfig(serverId);
     if (!existingConfig) {
-      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     await agent.updateMcpServer(serverId, config);
     if (persistToAgent === true) {
@@ -352,89 +380,122 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         import_core.logger.info(`Saved server '${serverId}' to agent configuration file`);
       } catch (saveError) {
         const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
-        import_core.logger.warn(
-          `Failed to persist MCP server '${serverId}' update: ${errorMessage}`,
-          { error: saveError }
-        );
+        import_core.logger.warn(`Failed to persist MCP server '${serverId}' update: ${errorMessage}`, {
+          error: saveError
+        });
       }
     }
     const status = config.enabled === false ? "registered" : "connected";
     return ctx.json({ status, name: serverId }, 200);
-  }).openapi(toolsRoute, async (ctx) => {
+  });
+  const serverToolsRouter = new import_zod_openapi.OpenAPIHono().openapi(toolsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
-      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     const toolsMap = await client.getTools();
     const tools = Object.entries(toolsMap).map(([toolName, toolDef]) => ({
       id: toolName,
       name: toolName,
       description: toolDef.description || "",
-      inputSchema: toolDef.parameters,
-      _meta: toolDef._meta
+      inputSchema: toolDef.parameters === void 0 ? void 0 : import_responses.ToolInputSchema.parse(toolDef.parameters),
+      _meta: toolDef._meta === void 0 ? void 0 : import_responses.JsonObjectSchema.parse(toolDef._meta)
     }));
-    return ctx.json({ tools });
-  }).openapi(deleteServerRoute, async (ctx) => {
+    const response = { tools };
+    return ctx.json(response, 200);
+  });
+  const deleteServerRouter = new import_zod_openapi.OpenAPIHono().openapi(deleteServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const clientExists = agent.getMcpClients().has(serverId) || agent.getMcpFailedConnections()[serverId];
     if (!clientExists) {
-      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     await agent.removeMcpServer(serverId);
-    return ctx.json({ status: "disconnected", id: serverId });
-  }).openapi(restartServerRoute, async (ctx) => {
+    const response = { status: "disconnected", id: serverId };
+    return ctx.json(response, 200);
+  });
+  const restartServerRouter = new import_zod_openapi.OpenAPIHono().openapi(restartServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     import_core.logger.info(`Received request to POST /api/mcp/servers/${serverId}/restart`);
     const clientExists = agent.getMcpClients().has(serverId);
     if (!clientExists) {
       import_core.logger.warn(`Attempted to restart non-existent server: ${serverId}`);
-      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     await agent.restartMcpServer(serverId);
-    return ctx.json({ status: "restarted", id: serverId });
-  }).openapi(execToolRoute, async (ctx) => {
+    const response = { status: "restarted", id: serverId };
+    return ctx.json(response, 200);
+  });
+  const execToolRouter = new import_zod_openapi.OpenAPIHono().openapi(execToolRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId, toolName } = ctx.req.valid("param");
     const body = ctx.req.valid("json");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
-      return ctx.json({ success: false, error: `Server '${serverId}' not found` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     try {
       const rawResult = await client.callTool(toolName, body);
-      return ctx.json({ success: true, data: rawResult });
+      const response = {
+        success: true,
+        data: import_responses.JsonValueSchema.parse(rawResult)
+      };
+      return ctx.json(response, 200);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       import_core.logger.error(
         `Tool execution failed for '${toolName}' on server '${serverId}': ${errorMessage}`,
         { error }
       );
-      return ctx.json({ success: false, error: errorMessage }, 200);
+      const response = {
+        success: false,
+        error: errorMessage
+      };
+      return ctx.json(response, 200);
     }
-  }).openapi(listResourcesRoute, async (ctx) => {
+  });
+  const listResourcesRouter = new import_zod_openapi.OpenAPIHono().openapi(listResourcesRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
-      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     const resources = await agent.listResourcesForServer(serverId);
-    return ctx.json({ success: true, resources });
-  }).openapi(getResourceContentRoute, async (ctx) => {
-    const agent = await getAgent(ctx);
-    const { serverId, resourceId } = ctx.req.valid("param");
-    const client = agent.getMcpClients().get(serverId);
-    if (!client) {
-      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
-    }
-    const qualifiedUri = `mcp:${serverId}:${resourceId}`;
-    const content = await agent.readResource(qualifiedUri);
-    return ctx.json({ success: true, data: { content } });
+    const response = { success: true, resources };
+    return ctx.json(response, 200);
   });
+  const getResourceContentRouter = new import_zod_openapi.OpenAPIHono().openapi(
+    getResourceContentRoute,
+    async (ctx) => {
+      const agent = await getAgent(ctx);
+      const { serverId, resourceId } = ctx.req.valid("param");
+      const client = agent.getMcpClients().get(serverId);
+      if (!client) {
+        throw import_core.MCPError.serverNotFound(serverId);
+      }
+      const qualifiedUri = `mcp:${serverId}:${resourceId}`;
+      const content = await agent.readResource(qualifiedUri);
+      const response = {
+        success: true,
+        data: { content: import_responses.JsonValueSchema.parse(content) }
+      };
+      return ctx.json(response, 200);
+    }
+  );
+  mountMcpSubrouter(app, serverRegistrationRouter);
+  mountMcpSubrouter(app, serverUpdateRouter);
+  mountMcpSubrouter(app, serverToolsRouter);
+  mountMcpSubrouter(app, deleteServerRouter);
+  mountMcpSubrouter(app, restartServerRouter);
+  mountMcpSubrouter(app, execToolRouter);
+  mountMcpSubrouter(app, listResourcesRouter);
+  mountMcpSubrouter(app, getResourceContentRouter);
+  return app;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {