@dexto/server 1.2.5

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

@@ -0,0 +1,246 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/mcp/servers": {
+        $post: {
+            input: {
+                json: {
+                    config: {
+                        type: "stdio";
+                        command: string;
+                        timeout?: number | undefined;
+                        args?: string[] | undefined;
+                        env?: Record<string, string> | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                    } | {
+                        type: "sse";
+                        url: string;
+                        timeout?: number | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    } | {
+                        type: "http";
+                        url: string;
+                        timeout?: number | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    };
+                    name: string;
+                    persistToAgent?: boolean | undefined;
+                };
+            };
+            output: {
+                status: string;
+                name: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers": {
+        $get: {
+            input: {};
+            output: {
+                servers: {
+                    status: "error" | "connected" | "disconnected";
+                    id: string;
+                    name: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/tools": {
+        $get: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                tools: {
+                    description: string;
+                    id: string;
+                    name: string;
+                    inputSchema?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        type?: "object" | undefined;
+                        properties?: {
+                            [x: string]: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                description?: string | undefined;
+                                default?: any;
+                                type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | undefined;
+                                enum?: (string | number | boolean)[] | undefined;
+                            };
+                        } | undefined;
+                        required?: string[] | undefined;
+                    } | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId": {
+        $delete: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                status: "disconnected";
+                id: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/restart": {
+        $post: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                status: "restarted";
+                id: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/tools/:toolName/execute": {
+        $post: {
+            input: {
+                param: {
+                    serverId: string;
+                    toolName: string;
+                };
+            } & {
+                json: Record<string, unknown>;
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                    toolName: string;
+                };
+            } & {
+                json: Record<string, unknown>;
+            };
+            output: {
+                success: boolean;
+                data?: any;
+                error?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/resources": {
+        $get: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                success: boolean;
+                resources: {
+                    uri: string;
+                    source: "mcp" | "internal";
+                    description?: string | undefined;
+                    mimeType?: string | undefined;
+                    name?: string | undefined;
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
+                    serverName?: string | undefined;
+                    size?: number | undefined;
+                    lastModified?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/resources/:resourceId/content": {
+        $get: {
+            input: {
+                param: {
+                    serverId: string;
+                    resourceId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                    resourceId: string;
+                };
+            };
+            output: {
+                data: {
+                    content?: any;
+                };
+                success: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=mcp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0I9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4SzD"}

package/dist/hono/routes/mcp.js

@@ -0,0 +1,332 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { logger, McpServerConfigSchema } from "@dexto/core";
+import { updateAgentConfigFile } from "@dexto/agent-management";
+import { ResourceSchema } 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"),
+  persistToAgent: z.boolean().optional().describe("If true, saves the server to agent configuration file")
+}).describe("Request body for adding or updating an MCP server");
+const ExecuteToolBodySchema = z.record(z.unknown()).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 = z.object({
+  status: z.string().describe("Connection status"),
+  name: z.string().describe("Server name")
+}).strict().describe("Server status response");
+const ServerInfoSchema = z.object({
+  id: z.string().describe("Server identifier"),
+  name: z.string().describe("Server name"),
+  status: z.enum(["connected", "error", "disconnected"]).describe("Server status")
+}).strict().describe("MCP server information");
+const ServersListResponseSchema = z.object({
+  servers: z.array(ServerInfoSchema).describe("Array of server information")
+}).strict().describe("List of MCP servers");
+const JsonSchemaProperty = z.object({
+  type: z.enum(["string", "number", "integer", "boolean", "object", "array"]).optional().describe("Property type"),
+  description: z.string().optional().describe("Property description"),
+  enum: z.array(z.union([z.string(), z.number(), z.boolean()])).optional().describe("Enum values"),
+  default: z.any().optional().describe("Default value")
+}).passthrough().describe("JSON Schema property definition");
+const ToolInputSchema = z.object({
+  type: z.literal("object").optional().describe('Schema type, always "object" when present'),
+  properties: z.record(JsonSchemaProperty).optional().describe("Property definitions"),
+  required: z.array(z.string()).optional().describe("Required property names")
+}).passthrough().describe("JSON Schema for tool input parameters");
+const ToolInfoSchema = z.object({
+  id: z.string().describe("Tool identifier"),
+  name: z.string().describe("Tool name"),
+  description: z.string().describe("Tool description"),
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+}).strict().describe("Tool information");
+const ToolsListResponseSchema = z.object({
+  tools: z.array(ToolInfoSchema).describe("Array of available tools")
+}).strict().describe("List of tools from MCP server");
+const DisconnectResponseSchema = z.object({
+  status: z.literal("disconnected").describe("Disconnection status"),
+  id: z.string().describe("Server identifier")
+}).strict().describe("Server disconnection response");
+const RestartResponseSchema = z.object({
+  status: z.literal("restarted").describe("Restart status"),
+  id: z.string().describe("Server identifier")
+}).strict().describe("Server restart response");
+const ToolExecutionResponseSchema = z.object({
+  success: z.boolean().describe("Whether tool execution succeeded"),
+  data: z.any().optional().describe("Tool execution result data"),
+  error: z.string().optional().describe("Error message if execution failed")
+}).strict().describe("Tool execution response");
+const ResourcesListResponseSchema = z.object({
+  success: z.boolean().describe("Success indicator"),
+  resources: z.array(ResourceSchema).describe("Array of available resources")
+}).strict().describe("List of resources from MCP server");
+const ResourceContentSchema = z.object({
+  content: z.any().describe("Resource content data")
+}).strict().describe("Resource content wrapper");
+const ResourceContentResponseSchema = z.object({
+  success: z.boolean().describe("Success indicator"),
+  data: ResourceContentSchema.describe("Resource content")
+}).strict().describe("Resource content response");
+function createMcpRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const addServerRoute = 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 = 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 toolsRoute = 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: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Tools list",
+        content: { "application/json": { schema: ToolsListResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const deleteServerRoute = createRoute({
+    method: "delete",
+    path: "/mcp/servers/{serverId}",
+    summary: "Remove MCP Server",
+    description: "Disconnects and removes an MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Disconnected",
+        content: { "application/json": { schema: DisconnectResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const restartServerRoute = createRoute({
+    method: "post",
+    path: "/mcp/servers/{serverId}/restart",
+    summary: "Restart MCP Server",
+    description: "Restarts a connected MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Server restarted",
+        content: { "application/json": { schema: RestartResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const execToolRoute = 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: z.object({
+        serverId: z.string().describe("The ID of the MCP server"),
+        toolName: 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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const listResourcesRoute = 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: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Server resources",
+        content: { "application/json": { schema: ResourcesListResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const getResourceContentRoute = 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: z.object({
+        serverId: z.string().describe("The ID of the MCP server"),
+        resourceId: 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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  return app.openapi(addServerRoute, async (ctx) => {
+    const agent = getAgent();
+    const { name, config, persistToAgent } = ctx.req.valid("json");
+    await agent.connectMcpServer(name, config);
+    logger.info(`Successfully connected to new server '${name}' via API request.`);
+    if (persistToAgent === true) {
+      try {
+        const currentConfig = agent.getEffectiveConfig();
+        const updates = {
+          mcpServers: {
+            ...currentConfig.mcpServers || {},
+            [name]: config
+          }
+        };
+        const newConfig = await updateAgentConfigFile(
+          agent.getAgentFilePath(),
+          updates
+        );
+        const reloadResult = await agent.reload(newConfig);
+        if (reloadResult.restarted) {
+          logger.info(
+            `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
+          );
+        }
+        logger.info(`Saved server '${name}' to agent configuration file`);
+      } catch (saveError) {
+        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
+        logger.warn(
+          `Failed to save server '${name}' to agent config: ${errorMessage}`,
+          {
+            error: saveError
+          }
+        );
+      }
+    }
+    return ctx.json({ status: "connected", name }, 200);
+  }).openapi(listServersRoute, async (ctx) => {
+    const agent = getAgent();
+    const clientsMap = agent.getMcpClients();
+    const failedConnections = agent.getMcpFailedConnections();
+    const servers = [];
+    for (const name of clientsMap.keys()) {
+      servers.push({ id: name, name, status: "connected" });
+    }
+    for (const name of Object.keys(failedConnections)) {
+      servers.push({ id: name, name, status: "error" });
+    }
+    return ctx.json({ servers });
+  }).openapi(toolsRoute, async (ctx) => {
+    const agent = getAgent();
+    const { serverId } = ctx.req.valid("param");
+    const client = agent.getMcpClients().get(serverId);
+    if (!client) {
+      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+    }
+    const toolsMap = await client.getTools();
+    const tools = Object.entries(toolsMap).map(([toolName, toolDef]) => ({
+      id: toolName,
+      name: toolName,
+      description: toolDef.description || "",
+      inputSchema: toolDef.parameters
+    }));
+    return ctx.json({ tools });
+  }).openapi(deleteServerRoute, async (ctx) => {
+    const agent = getAgent();
+    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);
+    }
+    await agent.removeMcpServer(serverId);
+    return ctx.json({ status: "disconnected", id: serverId });
+  }).openapi(restartServerRoute, async (ctx) => {
+    const agent = getAgent();
+    const { serverId } = ctx.req.valid("param");
+    logger.info(`Received request to POST /api/mcp/servers/${serverId}/restart`);
+    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);
+    }
+    await agent.restartMcpServer(serverId);
+    return ctx.json({ status: "restarted", id: serverId });
+  }).openapi(execToolRoute, async (ctx) => {
+    const agent = getAgent();
+    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);
+    }
+    try {
+      const rawResult = await client.callTool(toolName, body);
+      return ctx.json({ success: true, data: rawResult });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(
+        `Tool execution failed for '${toolName}' on server '${serverId}': ${errorMessage}`,
+        { error }
+      );
+      return ctx.json({ success: false, error: errorMessage }, 200);
+    }
+  }).openapi(listResourcesRoute, async (ctx) => {
+    const agent = getAgent();
+    const { serverId } = ctx.req.valid("param");
+    const client = agent.getMcpClients().get(serverId);
+    if (!client) {
+      return ctx.json({ error: `Server '${serverId}' not found` }, 404);
+    }
+    const resources = await agent.listResourcesForServer(serverId);
+    return ctx.json({ success: true, resources });
+  }).openapi(getResourceContentRoute, async (ctx) => {
+    const agent = getAgent();
+    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 } });
+  });
+}
+export {
+  createMcpRouter
+};