@dexto/server 1.5.8 → 1.6.1

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

@@ -1,16 +1,14 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-export declare function createDiscoveryRouter(): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+export type GetAgentConfigPathFn = (ctx: Context) => string | undefined | Promise<string | undefined>;
+export declare function createDiscoveryRouter(getAgentConfigPath: GetAgentConfigPathFn): OpenAPIHono<import("hono").Env, {
     "/discovery": {
         $get: {
             input: {};
             output: {
-                internalTools: {
-                    description: string;
-                    name: string;
-                }[];
-                customTools: {
+                blob: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
@@ -19,31 +17,35 @@ export declare function createDiscoveryRouter(): OpenAPIHono<import("hono").Env,
                 }[];
                 compaction: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
-                blob: {
+                database: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
-                database: {
+                toolFactories: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
+                builtinTools: {
+                    description: string;
+                    name: string;
+                }[];
             };
             outputFormat: "json";
             status: 200;

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

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAyChE,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsBpC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,MAAM,MAAM,oBAAoB,GAAG,CAC/B,GAAG,EAAE,OAAO,KACX,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAgJtD,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqB7E"}

package/dist/hono/routes/discovery.js

@@ -1,42 +1,109 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { listAllProviders } from "@dexto/core";
-const DiscoveredProviderSchema = z.object({
-  type: z.string().describe("Provider type identifier"),
-  category: z.enum(["blob", "database", "compaction", "customTools"]).describe("Provider category"),
+import { loadImage } from "@dexto/agent-config";
+import { loadAgentConfig } from "@dexto/agent-management";
+import imageLocal from "@dexto/image-local";
+const DiscoveredFactorySchema = z.object({
+  type: z.string().describe("Factory type identifier"),
+  category: z.enum(["blob", "database", "compaction", "tools"]).describe("Factory category"),
   metadata: z.object({
     displayName: z.string().optional().describe("Human-readable display name"),
-    description: z.string().optional().describe("Provider description")
-  }).passthrough().optional().describe("Optional metadata about the provider")
-}).describe("Information about a registered provider");
-const InternalToolSchema = z.object({
-  name: z.string().describe('Internal tool name identifier (e.g., "search_history", "ask_user")'),
+    description: z.string().optional().describe("Factory description")
+  }).passthrough().optional().describe("Optional metadata about the factory")
+}).describe("Information about a registered factory");
+const ToolSchema = z.object({
+  name: z.string().describe('Built-in tool name identifier (e.g., "search_history", "ask_user")'),
   description: z.string().describe("Human-readable description of what the tool does")
-}).describe("Information about an internal tool");
+}).describe("Information about a built-in tool");
 const DiscoveryResponseSchema = z.object({
-  blob: z.array(DiscoveredProviderSchema).describe("Blob storage providers"),
-  database: z.array(DiscoveredProviderSchema).describe("Database providers"),
-  compaction: z.array(DiscoveredProviderSchema).describe("Compaction strategy providers"),
-  customTools: z.array(DiscoveredProviderSchema).describe("Custom tool providers"),
-  internalTools: z.array(InternalToolSchema).describe("Internal tools available for configuration")
-}).describe("Discovery response with providers grouped by category");
-function createDiscoveryRouter() {
+  blob: z.array(DiscoveredFactorySchema).describe("Blob storage factories"),
+  database: z.array(DiscoveredFactorySchema).describe("Database factories"),
+  compaction: z.array(DiscoveredFactorySchema).describe("Compaction strategy factories"),
+  toolFactories: z.array(DiscoveredFactorySchema).describe("Tool factories"),
+  builtinTools: z.array(ToolSchema).describe("Built-in tools available for configuration")
+}).describe("Discovery response with factories grouped by category");
+function toMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  const record = metadata;
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      result[key] = value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+async function resolveImage(options) {
+  const { ctx, getAgentConfigPath } = options;
+  const configPath = await getAgentConfigPath(ctx);
+  if (!configPath) {
+    return imageLocal;
+  }
+  const rawConfig = await loadAgentConfig(configPath);
+  const imageName = (typeof rawConfig.image === "string" && rawConfig.image.length > 0 ? rawConfig.image : void 0) ?? process.env.DEXTO_IMAGE ?? "@dexto/image-local";
+  if (imageName === "@dexto/image-local") {
+    return imageLocal;
+  }
+  try {
+    return await loadImage(imageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load image module '${imageName}'. Ensure it is installed and that the host called setImageImporter(). Original error: ${message}`
+    );
+  }
+}
+async function listDiscoveryFactories(options) {
+  const image = await resolveImage(options);
+  const blob = Object.entries(image.storage.blob).map(([type, factory]) => ({
+    type,
+    category: "blob",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const database = Object.entries(image.storage.database).map(([type, factory]) => ({
+    type,
+    category: "database",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const compaction = Object.entries(image.compaction).map(([type, factory]) => ({
+    type,
+    category: "compaction",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const toolFactories = Object.entries(image.tools);
+  const builtinFactory = toolFactories.find(([type]) => type === "builtin-tools")?.[1];
+  const builtinTools = builtinFactory ? builtinFactory.create(builtinFactory.configSchema.parse({ type: "builtin-tools" })).map((tool) => ({
+    name: tool.id,
+    description: tool.description
+  })) : [];
+  const toolFactoriesList = toolFactories.filter(([type]) => type !== "builtin-tools").map(([type, factory]) => ({
+    type,
+    category: "tools",
+    metadata: toMetadata(factory.metadata)
+  }));
+  return { blob, database, compaction, toolFactories: toolFactoriesList, builtinTools };
+}
+function createDiscoveryRouter(getAgentConfigPath) {
   const app = new OpenAPIHono();
   const discoveryRoute = createRoute({
     method: "get",
     path: "/discovery",
-    summary: "Discover Available Providers and Tools",
-    description: "Returns all registered providers (blob storage, database, compaction, custom tools) and available internal tools. Useful for building UIs that need to display configurable options.",
+    summary: "Discover Available Factories and Tools",
+    description: "Returns all available factories (storage, compaction, tools) for the currently active image.",
     tags: ["discovery"],
     responses: {
       200: {
-        description: "Available providers grouped by category",
+        description: "Available factories grouped by category",
         content: { "application/json": { schema: DiscoveryResponseSchema } }
       }
     }
   });
   return app.openapi(discoveryRoute, async (ctx) => {
-    const providers = listAllProviders();
-    return ctx.json(providers);
+    return ctx.json(await listDiscoveryFactories({ ctx, getAgentConfigPath }));
   });
 }
 export {

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

@@ -450,9 +450,9 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
         $post: {
             input: {
                 json: {
+                    apiKey?: string | undefined;
                     model?: string | undefined;
                     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
-                    apiKey?: string | undefined;
                     maxInputTokens?: number | undefined;
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
@@ -559,8 +559,8 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                 };
             };
             output: {
-                ok: false;
                 error: string;
+                ok: false;
             };
             outputFormat: "json";
             status: 404;

package/dist/hono/routes/mcp.cjs

@@ -29,7 +29,11 @@ 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");
+}).strict().describe("Request body for adding or updating an MCP server");
+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(
   "Tool execution parameters as JSON object. The specific fields depend on the tool being executed and are defined by the tool's inputSchema."
 );
@@ -60,7 +64,8 @@ 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")
+  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)")
 }).strict().describe("Tool information");
 const ToolsListResponseSchema = import_zod_openapi.z.object({
   tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of available tools")
@@ -78,6 +83,10 @@ const ToolExecutionResponseSchema = import_zod_openapi.z.object({
   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 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 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")
@@ -89,7 +98,7 @@ 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) {
+function createMcpRouter(getAgent, getAgentConfigPath) {
   const app = new import_zod_openapi.OpenAPIHono();
   const addServerRoute = (0, import_zod_openapi.createRoute)({
     method: "post",
@@ -118,6 +127,41 @@ function createMcpRouter(getAgent) {
       }
     }
   });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  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 } }
+      },
+      404: { description: "Not found" }
+    }
+  });
   const toolsRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/mcp/servers/{serverId}/tools",
@@ -237,6 +281,10 @@ function createMcpRouter(getAgent) {
     );
     if (persistToAgent === true) {
       try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw import_core.AgentError.noConfigPath();
+        }
         const currentConfig = agent.getEffectiveConfig();
         const updates = {
           mcpServers: {
@@ -244,16 +292,7 @@ function createMcpRouter(getAgent) {
             [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(", ")}`
-          );
-        }
+        await (0, import_agent_management.updateAgentConfigFile)(agentPath, updates);
         import_core.logger.info(`Saved server '${name}' to agent configuration file`);
       } catch (saveError) {
         const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
@@ -279,6 +318,48 @@ function createMcpRouter(getAgent) {
       servers.push({ id: name, name, status: "error" });
     }
     return ctx.json({ servers });
+  }).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);
+    }
+    return ctx.json({ name: serverId, 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);
+    }
+    await agent.updateMcpServer(serverId, config);
+    if (persistToAgent === true) {
+      try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw import_core.AgentError.noConfigPath();
+        }
+        const currentConfig = agent.getEffectiveConfig();
+        const updates = {
+          mcpServers: {
+            ...currentConfig.mcpServers || {},
+            [serverId]: config
+          }
+        };
+        await (0, import_agent_management.updateAgentConfigFile)(agentPath, updates);
+        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 }
+        );
+      }
+    }
+    const status = config.enabled === false ? "registered" : "connected";
+    return ctx.json({ status, name: serverId }, 200);
   }).openapi(toolsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -291,7 +372,8 @@ function createMcpRouter(getAgent) {
       id: toolName,
       name: toolName,
       description: toolDef.description || "",
-      inputSchema: toolDef.parameters
+      inputSchema: toolDef.parameters,
+      _meta: toolDef._meta
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { GetAgentFn } from '../index.js';
-export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+import type { GetAgentConfigPathFn, GetAgentFn } from '../index.js';
+export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath: GetAgentConfigPathFn): OpenAPIHono<import("hono").Env, {
     "/mcp/servers": {
         $post: {
             input: {
@@ -9,8 +9,8 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                         type: "stdio";
                         command: string;
                         timeout?: number | undefined;
-                        enabled?: boolean | undefined;
                         args?: string[] | undefined;
+                        enabled?: boolean | undefined;
                         env?: Record<string, string> | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
                     } | {
@@ -55,6 +55,138 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             status: 200;
         };
     };
+} & {
+    "/mcp/servers/:serverId/config": {
+        $get: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                config: {
+                    timeout: number;
+                    type: "stdio";
+                    args: string[];
+                    command: string;
+                    enabled: boolean;
+                    env: {
+                        [x: string]: string;
+                    };
+                    connectionMode: "strict" | "lenient";
+                } | {
+                    timeout: number;
+                    type: "sse";
+                    enabled: boolean;
+                    connectionMode: "strict" | "lenient";
+                    url: string;
+                    headers: {
+                        [x: string]: string;
+                    };
+                } | {
+                    timeout: number;
+                    type: "http";
+                    enabled: boolean;
+                    connectionMode: "strict" | "lenient";
+                    url: string;
+                    headers: {
+                        [x: string]: string;
+                    };
+                };
+                name: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId": {
+        $put: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            } & {
+                json: {
+                    config: {
+                        type: "stdio";
+                        command: string;
+                        timeout?: number | undefined;
+                        args?: string[] | undefined;
+                        enabled?: boolean | undefined;
+                        env?: Record<string, string> | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                    } | {
+                        type: "sse";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    } | {
+                        type: "http";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    };
+                    persistToAgent?: boolean | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            } & {
+                json: {
+                    config: {
+                        type: "stdio";
+                        command: string;
+                        timeout?: number | undefined;
+                        args?: string[] | undefined;
+                        enabled?: boolean | undefined;
+                        env?: Record<string, string> | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                    } | {
+                        type: "sse";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    } | {
+                        type: "http";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    };
+                    persistToAgent?: boolean | undefined;
+                };
+            };
+            output: {
+                status: string;
+                name: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/mcp/servers/:serverId/tools": {
         $get: {
@@ -91,6 +223,9 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                         } | undefined;
                         required?: string[] | undefined;
                     } | undefined;
+                    _meta?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
                 }[];
             };
             outputFormat: "json";
@@ -197,7 +332,6 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                 };
             };
             output: {
-                success: boolean;
                 resources: {
                     uri: string;
                     source: "mcp" | "internal";
@@ -211,6 +345,7 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                     size?: number | undefined;
                     lastModified?: string | undefined;
                 }[];
+                success: boolean;
             };
             outputFormat: "json";
             status: 200;

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,UAAU,EAAE,MAAM,aAAa,CAAC;AAuI9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkTnD"}
+{"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"}