@dexto/server 1.2.5

package/dist/hono/routes/llm.js

@@ -0,0 +1,287 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import {
+  LLM_REGISTRY,
+  LLM_PROVIDERS,
+  LLM_ROUTERS,
+  SUPPORTED_FILE_TYPES,
+  getSupportedRoutersForProvider,
+  supportsBaseURL,
+  isRouterSupportedForModel,
+  LLMUpdatesSchema
+} from "@dexto/core";
+import { getProviderKeyStatus, saveProviderApiKey } from "@dexto/agent-management";
+import {
+  ProviderCatalogSchema,
+  ModelFlatSchema,
+  LLMConfigResponseSchema
+} from "../schemas/responses.js";
+const CurrentQuerySchema = z.object({
+  sessionId: z.string().optional().describe("Session identifier to retrieve session-specific LLM configuration")
+}).describe("Query parameters for getting current LLM configuration");
+const CatalogQuerySchema = z.object({
+  provider: z.union([z.string(), z.array(z.string())]).optional().transform(
+    (value) => Array.isArray(value) ? value : value ? value.split(",") : void 0
+  ).describe("Comma-separated list of LLM providers to filter by"),
+  hasKey: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
+    (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
+  ).describe("Filter by API key presence (true or false)"),
+  router: z.enum(LLM_ROUTERS).optional().describe("Filter by router type (vercel or in-built)"),
+  fileType: z.enum(SUPPORTED_FILE_TYPES).optional().describe("Filter by supported file type (audio, pdf, or image)"),
+  defaultOnly: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
+    (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
+  ).describe("Include only default models (true or false)"),
+  mode: z.enum(["grouped", "flat"]).default("grouped").describe("Response format mode (grouped by provider or flat list)")
+}).describe("Query parameters for filtering and formatting the LLM catalog");
+const SaveKeySchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider identifier (e.g., openai, anthropic)"),
+  apiKey: z.string().min(1, "API key is required").describe("API key for the provider (writeOnly - never returned in responses)").openapi({ writeOnly: true })
+}).describe("Request body for saving a provider API key");
+const SwitchLLMBodySchema = LLMUpdatesSchema.and(
+  z.object({
+    sessionId: z.string().optional().describe("Session identifier for session-specific LLM configuration")
+  })
+).describe("LLM switch request body with optional session ID and LLM fields");
+function createLlmRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const currentRoute = createRoute({
+    method: "get",
+    path: "/llm/current",
+    summary: "Get Current LLM Config",
+    description: "Retrieves the current LLM configuration for the agent or a specific session",
+    tags: ["llm"],
+    request: { query: CurrentQuerySchema },
+    responses: {
+      200: {
+        description: "Current LLM config",
+        content: {
+          "application/json": {
+            schema: z.object({
+              config: LLMConfigResponseSchema.partial({
+                maxIterations: true,
+                router: true
+              }).extend({
+                displayName: z.string().optional().describe("Human-readable model display name")
+              })
+            }).describe("Response containing current LLM configuration")
+          }
+        }
+      }
+    }
+  });
+  const catalogRoute = createRoute({
+    method: "get",
+    path: "/llm/catalog",
+    summary: "LLM Catalog",
+    description: "Providers, models, capabilities, and API key status",
+    tags: ["llm"],
+    request: { query: CatalogQuerySchema },
+    responses: {
+      200: {
+        description: "LLM catalog",
+        content: {
+          "application/json": {
+            schema: z.union([
+              z.object({
+                providers: z.record(z.enum(LLM_PROVIDERS), ProviderCatalogSchema).describe(
+                  "Providers grouped by ID with their models and capabilities"
+                )
+              }).strict().describe("Grouped catalog response (mode=grouped)"),
+              z.object({
+                models: z.array(ModelFlatSchema).describe(
+                  "Flat list of all models with provider information"
+                )
+              }).strict().describe("Flat catalog response (mode=flat)")
+            ]).describe(
+              "LLM catalog in grouped or flat format based on mode query parameter"
+            )
+          }
+        }
+      }
+    }
+  });
+  const saveKeyRoute = createRoute({
+    method: "post",
+    path: "/llm/key",
+    summary: "Save Provider API Key",
+    description: "Stores an API key for a provider in .env and makes it available immediately",
+    tags: ["llm"],
+    request: { body: { content: { "application/json": { schema: SaveKeySchema } } } },
+    responses: {
+      200: {
+        description: "API key saved",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Operation success indicator"),
+              provider: z.enum(LLM_PROVIDERS).describe("Provider for which the key was saved"),
+              envVar: z.string().describe("Environment variable name where key was stored")
+            }).strict().describe("API key save response")
+          }
+        }
+      }
+    }
+  });
+  const switchRoute = createRoute({
+    method: "post",
+    path: "/llm/switch",
+    summary: "Switch LLM",
+    description: "Switches the LLM configuration for the agent or a specific session",
+    tags: ["llm"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: SwitchLLMBodySchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "LLM switch result",
+        content: {
+          "application/json": {
+            schema: z.object({
+              config: LLMConfigResponseSchema.describe(
+                "New LLM configuration with all defaults applied (apiKey omitted)"
+              ),
+              sessionId: z.string().optional().describe("Session ID if session-specific switch")
+            }).describe("LLM switch result")
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(currentRoute, (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("query");
+    const currentConfig = sessionId ? agent.getEffectiveConfig(sessionId).llm : agent.getCurrentLLMConfig();
+    let displayName;
+    try {
+      const model = LLM_REGISTRY[currentConfig.provider]?.models.find(
+        (m) => m.name.toLowerCase() === String(currentConfig.model).toLowerCase()
+      );
+      displayName = model?.displayName || void 0;
+    } catch {
+    }
+    const { apiKey, ...configWithoutKey } = currentConfig;
+    return ctx.json({
+      config: {
+        ...configWithoutKey,
+        hasApiKey: !!apiKey,
+        ...displayName && { displayName }
+      }
+    });
+  }).openapi(catalogRoute, (ctx) => {
+    const queryParams = ctx.req.valid("query");
+    const providers = {};
+    for (const provider of LLM_PROVIDERS) {
+      const info = LLM_REGISTRY[provider];
+      const displayName = provider.charAt(0).toUpperCase() + provider.slice(1);
+      const keyStatus = getProviderKeyStatus(provider);
+      providers[provider] = {
+        name: displayName,
+        hasApiKey: keyStatus.hasApiKey,
+        primaryEnvVar: keyStatus.envVar,
+        supportedRouters: getSupportedRoutersForProvider(provider),
+        supportsBaseURL: supportsBaseURL(provider),
+        models: info.models,
+        supportedFileTypes: info.supportedFileTypes
+      };
+    }
+    let filtered = { ...providers };
+    if (queryParams.provider && queryParams.provider.length > 0) {
+      const allowed = new Set(
+        queryParams.provider.filter(
+          (p) => LLM_PROVIDERS.includes(p)
+        )
+      );
+      const filteredByProvider = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        if (allowed.has(id)) {
+          filteredByProvider[id] = catalog;
+        }
+      }
+      filtered = filteredByProvider;
+    }
+    if (typeof queryParams.hasKey === "boolean") {
+      const byKey = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        if (catalog.hasApiKey === queryParams.hasKey) {
+          byKey[id] = catalog;
+        }
+      }
+      filtered = byKey;
+    }
+    if (queryParams.router) {
+      const byRouter = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        if (!catalog.supportedRouters.includes(queryParams.router)) continue;
+        const models = catalog.models.filter(
+          (model) => isRouterSupportedForModel(
+            id,
+            model.name,
+            queryParams.router
+          )
+        );
+        if (models.length > 0) {
+          byRouter[id] = { ...catalog, models };
+        }
+      }
+      filtered = byRouter;
+    }
+    if (queryParams.fileType) {
+      const byFileType = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        const models = catalog.models.filter((model) => {
+          const modelTypes = Array.isArray(model.supportedFileTypes) && model.supportedFileTypes.length > 0 ? model.supportedFileTypes : catalog.supportedFileTypes || [];
+          return modelTypes.includes(queryParams.fileType);
+        });
+        if (models.length > 0) {
+          byFileType[id] = { ...catalog, models };
+        }
+      }
+      filtered = byFileType;
+    }
+    if (queryParams.defaultOnly) {
+      const byDefault = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        const models = catalog.models.filter((model) => model.default === true);
+        if (models.length > 0) {
+          byDefault[id] = { ...catalog, models };
+        }
+      }
+      filtered = byDefault;
+    }
+    if (queryParams.mode === "flat") {
+      const flat = [];
+      for (const [id, catalog] of Object.entries(filtered)) {
+        for (const model of catalog.models) {
+          flat.push({ provider: id, ...model });
+        }
+      }
+      return ctx.json({ models: flat });
+    }
+    return ctx.json({ providers: filtered });
+  }).openapi(saveKeyRoute, async (ctx) => {
+    const { provider, apiKey } = ctx.req.valid("json");
+    const meta = await saveProviderApiKey(provider, apiKey, process.cwd());
+    return ctx.json({ ok: true, provider, envVar: meta.envVar });
+  }).openapi(switchRoute, async (ctx) => {
+    const agent = getAgent();
+    const raw = ctx.req.valid("json");
+    const { sessionId, ...llmUpdates } = raw;
+    const config = await agent.switchLLM(llmUpdates, sessionId);
+    const { apiKey, ...configWithoutKey } = config;
+    return ctx.json({
+      config: {
+        ...configWithoutKey,
+        hasApiKey: !!apiKey
+      },
+      sessionId
+    });
+  });
+}
+export {
+  createLlmRouter
+};

package/dist/hono/routes/mcp.cjs

@@ -0,0 +1,356 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_exports = {};
+__export(mcp_exports, {
+  createMcpRouter: () => createMcpRouter
+});
+module.exports = __toCommonJS(mcp_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_agent_management = require("@dexto/agent-management");
+var import_responses = require("../schemas/responses.js");
+const McpServerRequestSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().min(1, "Server name is required").describe("A unique name for the server"),
+  config: import_core.McpServerConfigSchema.describe("The server configuration object"),
+  persistToAgent: import_zod_openapi.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 = import_zod_openapi.z.record(import_zod_openapi.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 = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.string().describe("Connection status"),
+  name: import_zod_openapi.z.string().describe("Server name")
+}).strict().describe("Server status response");
+const ServerInfoSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Server identifier"),
+  name: import_zod_openapi.z.string().describe("Server name"),
+  status: import_zod_openapi.z.enum(["connected", "error", "disconnected"]).describe("Server status")
+}).strict().describe("MCP server information");
+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")
+}).strict().describe("Tool information");
+const ToolsListResponseSchema = import_zod_openapi.z.object({
+  tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of available tools")
+}).strict().describe("List of tools from MCP server");
+const DisconnectResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.literal("disconnected").describe("Disconnection status"),
+  id: import_zod_openapi.z.string().describe("Server identifier")
+}).strict().describe("Server disconnection response");
+const RestartResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.literal("restarted").describe("Restart status"),
+  id: import_zod_openapi.z.string().describe("Server identifier")
+}).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"),
+  error: import_zod_openapi.z.string().optional().describe("Error message if execution failed")
+}).strict().describe("Tool execution response");
+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")
+}).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")
+}).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) {
+  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 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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      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);
+    import_core.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 (0, import_agent_management.updateAgentConfigFile)(
+          agent.getAgentFilePath(),
+          updates
+        );
+        const reloadResult = await agent.reload(newConfig);
+        if (reloadResult.restarted) {
+          import_core.logger.info(
+            `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
+          );
+        }
+        import_core.logger.info(`Saved server '${name}' to agent configuration file`);
+      } catch (saveError) {
+        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
+        import_core.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");
+    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);
+    }
+    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);
+      import_core.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 } });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMcpRouter
+});