@dexto/server 1.6.19 → 1.6.20

package/dist/hono/routes/mcp.cjs

@@ -87,9 +87,15 @@ 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")
@@ -141,7 +147,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -159,7 +168,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -176,7 +188,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -193,7 +208,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -210,7 +228,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -231,7 +252,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -248,7 +272,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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)({
@@ -268,7 +295,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         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) => {
@@ -317,22 +347,22 @@ 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);
+    return ctx.json({ name: serverId, config: import_core.McpServerConfigSchema.parse(config) }, 200);
   }).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) {
@@ -365,26 +395,26 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     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,
+      inputSchema: toolDef.parameters === void 0 ? void 0 : ToolInputSchema.parse(toolDef.parameters),
       _meta: toolDef._meta
     }));
-    return ctx.json({ tools });
+    return ctx.json({ tools }, 200);
   }).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 });
+    return ctx.json({ status: "disconnected", id: serverId }, 200);
   }).openapi(restartServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -392,21 +422,21 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     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 });
+    return ctx.json({ status: "restarted", id: serverId }, 200);
   }).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 });
+      return ctx.json({ success: true, data: rawResult }, 200);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       import_core.logger.error(
@@ -420,20 +450,20 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     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 });
+    return ctx.json({ success: true, resources }, 200);
   }).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);
+      throw import_core.MCPError.serverNotFound(serverId);
     }
     const qualifiedUri = `mcp:${serverId}:${resourceId}`;
     const content = await agent.readResource(qualifiedUri);
-    return ctx.json({ success: true, data: { content } });
+    return ctx.json({ success: true, data: { content } }, 200);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/hono/routes/mcp.d.ts

@@ -47,8 +47,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
             output: {
                 servers: {
                     status: "error" | "connected" | "disconnected" | "auth-required";
-                    id: string;
                     name: string;
+                    id: string;
                 }[];
             };
             outputFormat: "json";
@@ -63,8 +63,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     serverId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -143,8 +143,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     persistToAgent?: boolean | undefined;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -195,8 +195,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     serverId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -207,8 +207,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
             output: {
                 tools: {
                     description: string;
-                    id: string;
                     name: string;
+                    id: string;
                     inputSchema?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         type?: "object" | undefined;
@@ -240,8 +240,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     serverId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -265,8 +265,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     serverId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -293,8 +293,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
             } & {
                 json: Record<string, unknown>;
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -307,8 +307,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
             };
             output: {
                 success: boolean;
-                data?: any;
                 error?: string | undefined;
+                data?: any;
             };
             outputFormat: "json";
             status: 200;
@@ -322,8 +322,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     serverId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {
@@ -333,17 +333,10 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
             };
             output: {
                 resources: {
+                    name: string;
                     uri: string;
-                    source: "mcp" | "internal";
-                    description?: string | undefined;
-                    mimeType?: string | undefined;
-                    metadata?: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | undefined;
-                    name?: string | undefined;
-                    serverName?: string | undefined;
-                    size?: number | undefined;
-                    lastModified?: string | undefined;
+                    serverName: string;
+                    originalUri: string;
                 }[];
                 success: boolean;
             };
@@ -360,8 +353,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath
                     resourceId: string;
                 };
             };
-            output: {};
-            outputFormat: string;
+            output: never;
+            outputFormat: "json";
             status: 404;
         } | {
             input: {

package/dist/hono/routes/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA+JpE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuY7F"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAUhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyKpE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAka7F"}

package/dist/hono/routes/mcp.js

@@ -1,7 +1,13 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { AgentError, logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
+import {
+  AgentError,
+  logger,
+  MCPError,
+  McpServerConfigSchema,
+  MCP_CONNECTION_STATUSES
+} from "@dexto/core";
 import { updateAgentConfigFile } from "@dexto/agent-management";
-import { ResourceSchema } from "../schemas/responses.js";
+import { ApiErrorResponseSchema } from "../schemas/responses.js";
 const McpServerRequestSchema = z.object({
   name: z.string().min(1, "Server name is required").describe("A unique name for the server"),
   config: McpServerConfigSchema.describe("The server configuration object"),
@@ -64,9 +70,15 @@ const ServerConfigResponseSchema = z.object({
   name: z.string().describe("Server name"),
   config: McpServerConfigSchema.describe("Server configuration")
 }).strict().describe("MCP server configuration response");
+const ServerResourceSchema = z.object({
+  uri: z.string().describe("Resolved resource URI for this server"),
+  name: z.string().describe("Resource display name"),
+  originalUri: z.string().describe("Original MCP resource URI"),
+  serverName: z.string().describe("Owning MCP server name")
+}).strict().describe("Resource exposed by a specific MCP server");
 const ResourcesListResponseSchema = z.object({
   success: z.boolean().describe("Success indicator"),
-  resources: z.array(ResourceSchema).describe("Array of available resources")
+  resources: z.array(ServerResourceSchema).describe("Array of available resources")
 }).strict().describe("List of resources from MCP server");
 const ResourceContentSchema = z.object({
   content: z.any().describe("Resource content data")
@@ -118,7 +130,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Server configuration",
         content: { "application/json": { schema: ServerConfigResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const updateServerRoute = createRoute({
@@ -136,7 +151,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Server updated",
         content: { "application/json": { schema: ServerStatusResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const toolsRoute = createRoute({
@@ -153,7 +171,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Tools list",
         content: { "application/json": { schema: ToolsListResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const deleteServerRoute = createRoute({
@@ -170,7 +191,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Disconnected",
         content: { "application/json": { schema: DisconnectResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const restartServerRoute = createRoute({
@@ -187,7 +211,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Server restarted",
         content: { "application/json": { schema: RestartResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const execToolRoute = createRoute({
@@ -208,7 +235,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Tool executed",
         content: { "application/json": { schema: ToolExecutionResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const listResourcesRoute = createRoute({
@@ -225,7 +255,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Server resources",
         content: { "application/json": { schema: ResourcesListResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   const getResourceContentRoute = createRoute({
@@ -245,7 +278,10 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
         description: "Resource content",
         content: { "application/json": { schema: ResourceContentResponseSchema } }
       },
-      404: { description: "Not found" }
+      404: {
+        description: "Not found",
+        content: { "application/json": { schema: ApiErrorResponseSchema } }
+      }
     }
   });
   return app.openapi(addServerRoute, async (ctx) => {
@@ -294,22 +330,22 @@ 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 MCPError.serverNotFound(serverId);
     }
-    return ctx.json({ name: serverId, config }, 200);
+    return ctx.json({ name: serverId, config: McpServerConfigSchema.parse(config) }, 200);
   }).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 MCPError.serverNotFound(serverId);
     }
     await agent.updateMcpServer(serverId, config);
     if (persistToAgent === true) {
@@ -342,26 +378,26 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
-      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+      throw 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,
+      inputSchema: toolDef.parameters === void 0 ? void 0 : ToolInputSchema.parse(toolDef.parameters),
       _meta: toolDef._meta
     }));
-    return ctx.json({ tools });
+    return ctx.json({ tools }, 200);
   }).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 MCPError.serverNotFound(serverId);
     }
     await agent.removeMcpServer(serverId);
-    return ctx.json({ status: "disconnected", id: serverId });
+    return ctx.json({ status: "disconnected", id: serverId }, 200);
   }).openapi(restartServerRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -369,21 +405,21 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     const clientExists = agent.getMcpClients().has(serverId);
     if (!clientExists) {
       logger.warn(`Attempted to restart non-existent server: ${serverId}`);
-      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+      throw MCPError.serverNotFound(serverId);
     }
     await agent.restartMcpServer(serverId);
-    return ctx.json({ status: "restarted", id: serverId });
+    return ctx.json({ status: "restarted", id: serverId }, 200);
   }).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 MCPError.serverNotFound(serverId);
     }
     try {
       const rawResult = await client.callTool(toolName, body);
-      return ctx.json({ success: true, data: rawResult });
+      return ctx.json({ success: true, data: rawResult }, 200);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(
@@ -397,20 +433,20 @@ function createMcpRouter(getAgent, getAgentConfigPath) {
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
-      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+      throw MCPError.serverNotFound(serverId);
     }
     const resources = await agent.listResourcesForServer(serverId);
-    return ctx.json({ success: true, resources });
+    return ctx.json({ success: true, resources }, 200);
   }).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);
+      throw MCPError.serverNotFound(serverId);
     }
     const qualifiedUri = `mcp:${serverId}:${resourceId}`;
     const content = await agent.readResource(qualifiedUri);
-    return ctx.json({ success: true, data: { content } });
+    return ctx.json({ success: true, data: { content } }, 200);
   });
 }
 export {