dexto 1.13.4 → 1.14.0

package/dist/api/mcp/http-gateway.d.ts

@@ -0,0 +1,21 @@
+import { type IncomingHttpHeaders } from 'node:http';
+import type { ValidatedServersConfig } from '@dexto/core/mcp';
+import type { HttpAuthorization } from '@dexto/server/hono/auth';
+export interface McpHttpAggregationGateway {
+    port: number;
+    close(): Promise<void>;
+}
+interface HttpAggregationOptions {
+    name: string;
+    version: string;
+    strict: boolean;
+    host: string;
+    port: number;
+    authorize: HttpAuthorization;
+}
+/** HTTP authority checks protect open loopback listeners against browser rebinding. */
+export declare function allowsMcpHttpRequestOrigin(host: string, port: number, headers: IncomingHttpHeaders): boolean;
+/** Stateless MCP HTTP requests share one host-owned upstream discovery snapshot. */
+export declare function startMcpHttpAggregationGateway(configs: ValidatedServersConfig, options: HttpAggregationOptions): Promise<McpHttpAggregationGateway>;
+export {};
+//# sourceMappingURL=http-gateway.d.ts.map

package/dist/api/mcp/http-gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-gateway.d.ts","sourceRoot":"","sources":["../../../src/api/mcp/http-gateway.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAGnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,UAAU,sBAAsB;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;CAChC;AAED,uFAAuF;AACvF,wBAAgB,0BAA0B,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,mBAAmB,GAC7B,OAAO,CAQT;AAED,oFAAoF;AACpF,wBAAsB,8BAA8B,CAChD,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,sBAAsB,GAChC,OAAO,CAAC,yBAAyB,CAAC,CAqGpC"}

package/dist/api/mcp/http-gateway.js

@@ -0,0 +1,110 @@
+import { isIP } from 'node:net';
+import { createServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { initializeMcpToolAggregationHost } from './tool-aggregation-handler.js';
+/** HTTP authority checks protect open loopback listeners against browser rebinding. */
+export function allowsMcpHttpRequestOrigin(host, port, headers) {
+    const listenerHost = isIP(host) === 6 ? `[${host}]` : host;
+    const listener = new URL(`http://${listenerHost}:${port}`);
+    const loopback = host === '127.0.0.1' || host === '::1';
+    return ((!loopback || headers.host === listener.host) &&
+        (headers.origin === undefined || headers.origin === listener.origin));
+}
+/** Stateless MCP HTTP requests share one host-owned upstream discovery snapshot. */
+export async function startMcpHttpAggregationGateway(configs, options) {
+    const owner = await initializeMcpToolAggregationHost(configs, options.name, options.version, options.strict);
+    const server = createServer((request, response) => {
+        // Authorization precedes routing, body parsing and downstream protocol allocation.
+        const authorization = options.authorize(request.headers.authorization);
+        if (!authorization.allowed) {
+            response.writeHead(authorization.status, { 'content-type': 'application/json' });
+            response.end(JSON.stringify(authorization.body));
+            return;
+        }
+        const address = server.address();
+        if (address === null || typeof address === 'string') {
+            response.writeHead(503).end();
+            return;
+        }
+        if (!allowsMcpHttpRequestOrigin(options.host, address.port, request.headers)) {
+            response.writeHead(403).end();
+            return;
+        }
+        if (request.url?.split('?')[0] !== '/mcp') {
+            response.writeHead(404).end();
+            return;
+        }
+        if (request.method !== 'POST') {
+            response.writeHead(405, { allow: 'POST' }).end();
+            return;
+        }
+        // SDK stateless transports cannot be reused, even by a single HTTP client.
+        const transport = new StreamableHTTPServerTransport({
+            enableJsonResponse: true,
+        });
+        // The SDK class implements Transport, but its callback getters include undefined,
+        // conflicting with Transport's optional properties under exactOptionalPropertyTypes.
+        const peer = owner.connect(transport);
+        let closePromise;
+        const closeRequest = () => {
+            response.off('close', closeRequest);
+            response.off('finish', closeRequest);
+            if (closePromise !== undefined)
+                return;
+            closePromise = peer.then((connection) => connection.close());
+            void closePromise.catch(() => {
+                process.stderr.write('MCP HTTP request cleanup failed.\n');
+            });
+        };
+        response.once('close', closeRequest);
+        response.once('finish', closeRequest);
+        void peer
+            .then(() => transport.handleRequest(request, response))
+            .catch(() => {
+            if (!response.headersSent)
+                response.writeHead(500);
+            response.end();
+            closeRequest();
+        });
+    });
+    let closePromise;
+    const close = () => {
+        closePromise ??= Promise.resolve().then(async () => {
+            const listenerClosed = server.listening
+                ? new Promise((resolve, reject) => {
+                    server.close((error) => (error ? reject(error) : resolve()));
+                    server.closeAllConnections();
+                })
+                : Promise.resolve();
+            const results = await Promise.allSettled([listenerClosed, owner.close()]);
+            const failures = results.filter((result) => result.status === 'rejected');
+            if (failures.length > 0) {
+                throw new AggregateError(failures.map((result) => result.reason), 'MCP HTTP gateway cleanup failed');
+            }
+        });
+        return closePromise;
+    };
+    try {
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(options.port, options.host);
+        });
+        const address = server.address();
+        if (address === null || typeof address === 'string')
+            throw new Error('MCP HTTP listener address unavailable');
+        return { port: address.port, close };
+    }
+    catch (error) {
+        await close().catch(() => undefined);
+        throw error;
+    }
+}

package/dist/api/mcp/tool-aggregation-handler.d.ts

@@ -1,9 +1,12 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import { type ValidatedServersConfig } from '@dexto/core';
-/**
- * Initializes MCP server for tool aggregation mode.
- * Instead of exposing an AI agent, this directly exposes all tools from connected MCP servers.
- */
-export declare function initializeMcpToolAggregationServer(serverConfigs: ValidatedServersConfig, mcpTransport: Transport, serverName: string, serverVersion: string, _strict: boolean): Promise<McpServer>;
+import { type ValidatedServersConfig } from '@dexto/core/mcp';
+export interface McpToolAggregationHost {
+    connect(transport: Transport): Promise<McpServer>;
+    close(): Promise<void>;
+}
+/** One upstream discovery snapshot shared by independently connected downstream peers. */
+export declare function initializeMcpToolAggregationHost(serverConfigs: ValidatedServersConfig, serverName: string, serverVersion: string, strict: boolean): Promise<McpToolAggregationHost>;
+/** Stdio-compatible owner: closing its downstream peer also closes its upstream snapshot. */
+export declare function initializeMcpToolAggregationServer(serverConfigs: ValidatedServersConfig, mcpTransport: Transport, serverName: string, serverVersion: string, strict: boolean): Promise<McpServer>;
 //# sourceMappingURL=tool-aggregation-handler.d.ts.map

package/dist/api/mcp/tool-aggregation-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-aggregation-handler.d.ts","sourceRoot":"","sources":["../../../src/api/mcp/tool-aggregation-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAGH,KAAK,sBAAsB,EAI9B,MAAM,aAAa,CAAC;AAGrB;;;GAGG;AACH,wBAAsB,kCAAkC,CACpD,aAAa,EAAE,sBAAsB,EACrC,YAAY,EAAE,SAAS,EACvB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,GACjB,OAAO,CAAC,SAAS,CAAC,CAwGpB"}
+{"version":3,"file":"tool-aggregation-handler.d.ts","sourceRoot":"","sources":["../../../src/api/mcp/tool-aggregation-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAA4B,KAAK,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAiBxF,MAAM,WAAW,sBAAsB;IACnC,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAClD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,0FAA0F;AAC1F,wBAAsB,gCAAgC,CAClD,aAAa,EAAE,sBAAsB,EACrC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,OAAO,GAChB,OAAO,CAAC,sBAAsB,CAAC,CA8PjC;AAED,6FAA6F;AAC7F,wBAAsB,kCAAkC,CACpD,aAAa,EAAE,sBAAsB,EACrC,YAAY,EAAE,SAAS,EACvB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,OAAO,GAChB,OAAO,CAAC,SAAS,CAAC,CAuBpB"}

package/dist/api/mcp/tool-aggregation-handler.js

@@ -1,92 +1,225 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { MCPManager, logger, jsonSchemaToZodShape, createLogger, DextoLogComponent, } from '@dexto/core';
-import { z } from 'zod';
-/**
- * Initializes MCP server for tool aggregation mode.
- * Instead of exposing an AI agent, this directly exposes all tools from connected MCP servers.
- */
-export async function initializeMcpToolAggregationServer(serverConfigs, mcpTransport, serverName, serverVersion, _strict) {
-    // Create MCP manager with no confirmation provider (tools are auto-approved)
+import { MCPManager, MCPErrorCode } from '@dexto/core/mcp';
+import { createLogger, DextoLogComponent } from '@dexto/core/logger';
+import { ListToolsRequestSchema, CallToolRequestSchema, McpError, ErrorCode, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+/** One upstream discovery snapshot shared by independently connected downstream peers. */
+export async function initializeMcpToolAggregationHost(serverConfigs, serverName, serverVersion, strict) {
+    // Manager diagnostics can contain upstream payloads; keep them off protocol streams.
     const mcpLogger = createLogger({
         config: {
             level: 'info',
-            transports: [{ type: 'console', colorize: true }],
+            transports: [{ type: 'silent' }],
         },
         agentId: 'mcp-tool-aggregation',
         component: DextoLogComponent.MCP,
     });
     const mcpManager = new MCPManager(mcpLogger);
-    // Initialize all MCP server connections from config
-    logger.info('Connecting to configured MCP servers for tool aggregation...');
-    await mcpManager.initializeFromConfig(serverConfigs);
-    // Create the aggregation MCP server
-    const mcpServer = new McpServer({ name: serverName, version: serverVersion }, {
-        capabilities: {
-            tools: {},
-            resources: {},
-            prompts: {},
-        },
-    });
-    const toolDefinitions = await mcpManager.getAllTools();
-    let toolCount = 0;
-    for (const [toolName, toolDef] of Object.entries(toolDefinitions)) {
-        toolCount++;
-        const jsonSchema = toolDef.parameters ?? { type: 'object', properties: {} };
-        const paramsShape = jsonSchemaToZodShape(jsonSchema);
-        const _paramsSchema = z.object(paramsShape);
-        logger.debug(`Registering tool '${toolName}' with schema: ${JSON.stringify(jsonSchema)}`);
-        mcpServer.tool(toolName, toolDef.description || `Tool: ${toolName}`, paramsShape, async (args) => {
-            logger.info(`Tool aggregation: executing ${toolName}`);
-            try {
-                const result = await mcpManager.executeTool(toolName, args);
-                logger.info(`Tool aggregation: ${toolName} completed successfully`);
-                return result;
-            }
-            catch (error) {
-                logger.error(`Tool aggregation: ${toolName} failed: ${error}`);
-                throw error;
+    const peers = new Map();
+    const attaching = new Set();
+    let closePromise;
+    const close = () => {
+        closePromise ??= Promise.resolve().then(async () => {
+            await Promise.allSettled(Array.from(attaching));
+            const results = await Promise.allSettled(Array.from(peers.values(), (closePeer) => closePeer()));
+            results.push(...(await Promise.allSettled([mcpManager.disconnectAll()])));
+            results.push(...(await Promise.allSettled([mcpLogger.destroy()])));
+            const failures = results.filter((result) => result.status === 'rejected');
+            if (failures.length > 0) {
+                throw new AggregateError(failures.map((result) => result.reason), 'MCP aggregation cleanup failed');
             }
         });
+        return closePromise;
+    };
+    const connectionConfigs = { ...serverConfigs };
+    if (strict) {
+        for (const [name, config] of Object.entries(serverConfigs)) {
+            if (config.enabled)
+                connectionConfigs[name] = { ...config, connectionMode: 'strict' };
+        }
     }
-    logger.info(`Registered ${toolCount} tools from connected MCP servers`);
-    // Register resources if available
     try {
-        const allResources = await mcpManager.listAllResources();
-        logger.info(`Registering ${allResources.length} resources from connected MCP servers`);
-        // Collision handling verified:
-        // - Tools/Prompts: Names come from mcpManager which handles collisions at source
-        // - Resources: Index prefix ensures uniqueness even if multiple clients have same key
-        allResources.forEach((resource, index) => {
-            const safeId = resource.key.replace(/[^a-zA-Z0-9]/g, '_');
-            mcpServer.resource(`resource_${index}_${safeId}`, resource.key, async () => {
-                logger.info(`Resource aggregation: reading ${resource.key}`);
-                return await mcpManager.readResource(resource.key);
+        await mcpManager.initializeFromConfig(connectionConfigs);
+        if (Object.values(mcpManager.getFailedConnections()).some((error) => error.code === MCPErrorCode.DUPLICATE_NAME)) {
+            throw new Error('Duplicate upstream server identity');
+        }
+        const tools = new Map();
+        const discovered = new Map();
+        await Promise.all(Array.from(mcpManager.getClients(), async ([name, connection]) => {
+            const config = serverConfigs[name];
+            if (config === undefined)
+                throw new Error('Missing upstream connection configuration');
+            const client = await connection.getConnectedClient();
+            const capabilities = client.getServerCapabilities();
+            const options = { timeout: config.timeout };
+            const [toolResult, resourceResult, promptResult] = await Promise.all([
+                capabilities?.tools ? client.listTools(undefined, options) : { tools: [] },
+                capabilities?.resources
+                    ? client.listResources(undefined, options)
+                    : { resources: [] },
+                capabilities?.prompts
+                    ? client.listPrompts(undefined, options)
+                    : { prompts: [] },
+            ]);
+            const upstreamTools = new Map(toolResult.tools.map((tool) => [tool.name, tool]));
+            if (upstreamTools.size !== toolResult.tools.length)
+                throw new Error('Duplicate upstream tool identity');
+            const upstreamResources = new Map(resourceResult.resources.map((resource) => [resource.uri, resource]));
+            if (upstreamResources.size !== resourceResult.resources.length)
+                throw new Error('Duplicate upstream resource identity');
+            discovered.set(name, {
+                client,
+                tools: upstreamTools,
+                resources: upstreamResources,
+                prompts: promptResult.prompts,
+                timeout: config.timeout,
             });
-        });
+        }));
+        let discoveredCount = 0;
+        for (const upstream of discovered.values())
+            discoveredCount += upstream.tools.size;
+        const aliases = mcpManager.getAllToolsWithServerInfo();
+        if (aliases.size !== discoveredCount)
+            throw new Error('Ambiguous aggregation tool aliases');
+        for (const [alias, entry] of aliases) {
+            const upstream = discovered.get(entry.serverName);
+            const definition = upstream?.tools.get(entry.upstreamToolName);
+            if (upstream === undefined || definition === undefined) {
+                throw new Error('Aggregation tool identity changed during startup');
+            }
+            tools.set(alias, {
+                definition: { ...definition, name: alias },
+                client: upstream.client,
+                name: entry.upstreamToolName,
+                timeout: upstream.timeout,
+            });
+        }
+        const resources = new Map();
+        const cachedResources = await mcpManager.listAllResources();
+        let discoveredResourceCount = 0;
+        for (const upstream of discovered.values())
+            discoveredResourceCount += upstream.resources.size;
+        if (cachedResources.length !== discoveredResourceCount)
+            throw new Error('Ambiguous aggregation resource identities');
+        for (const resource of cachedResources) {
+            const upstream = discovered.get(resource.serverName);
+            const definition = upstream?.resources.get(resource.summary.uri);
+            if (upstream === undefined || definition === undefined)
+                throw new Error('Aggregation resource identity changed during startup');
+            resources.set(resource.key, {
+                definition: { ...definition, uri: resource.key },
+                client: upstream.client,
+                uri: definition.uri,
+                timeout: upstream.timeout,
+            });
+        }
+        const prompts = new Map();
+        for (const upstream of discovered.values()) {
+            for (const prompt of upstream.prompts) {
+                if (prompts.has(prompt.name))
+                    throw new Error('Duplicate aggregation prompt identity');
+                prompts.set(prompt.name, {
+                    definition: prompt,
+                    client: upstream.client,
+                    timeout: upstream.timeout,
+                });
+            }
+        }
+        return {
+            close,
+            async connect(transport) {
+                if (closePromise !== undefined)
+                    throw new Error('MCP aggregation host is closing');
+                const attachment = (async () => {
+                    const mcpServer = new McpServer({ name: serverName, version: serverVersion }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+                    const originalClose = mcpServer.close.bind(mcpServer);
+                    let peerClosePromise;
+                    const closePeer = () => (peerClosePromise ??= originalClose());
+                    mcpServer.close = closePeer;
+                    peers.set(mcpServer, closePeer);
+                    const previousClose = mcpServer.server.onclose;
+                    mcpServer.server.onclose = () => {
+                        peers.delete(mcpServer);
+                        previousClose?.();
+                    };
+                    mcpServer.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+                        tools: Array.from(tools.values(), (tool) => tool.definition),
+                    }));
+                    mcpServer.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+                        const tool = tools.get(request.params.name);
+                        if (tool === undefined)
+                            throw new McpError(ErrorCode.InvalidParams, 'Unknown aggregation tool');
+                        return tool.client.callTool({ ...request.params, name: tool.name }, undefined, {
+                            signal: extra.signal,
+                            timeout: tool.timeout,
+                        });
+                    });
+                    mcpServer.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+                        resources: Array.from(resources.values(), (resource) => resource.definition),
+                    }));
+                    mcpServer.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
+                        const resource = resources.get(request.params.uri);
+                        if (resource === undefined)
+                            throw new McpError(ErrorCode.InvalidParams, 'Unknown aggregation resource');
+                        return resource.client.readResource({ ...request.params, uri: resource.uri }, { signal: extra.signal, timeout: resource.timeout });
+                    });
+                    mcpServer.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+                        prompts: Array.from(prompts.values(), (prompt) => prompt.definition),
+                    }));
+                    mcpServer.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
+                        const prompt = prompts.get(request.params.name);
+                        if (prompt === undefined)
+                            throw new McpError(ErrorCode.InvalidParams, 'Unknown aggregation prompt');
+                        return prompt.client.getPrompt(request.params, {
+                            signal: extra.signal,
+                            timeout: prompt.timeout,
+                        });
+                    });
+                    try {
+                        await mcpServer.connect(transport);
+                        if (closePromise !== undefined)
+                            throw new Error('MCP aggregation host is closing');
+                        return mcpServer;
+                    }
+                    catch (error) {
+                        await closePeer().catch(() => undefined);
+                        peers.delete(mcpServer);
+                        throw error;
+                    }
+                })();
+                attaching.add(attachment);
+                try {
+                    return await attachment;
+                }
+                finally {
+                    attaching.delete(attachment);
+                }
+            },
+        };
     }
     catch (error) {
-        logger.debug(`Skipping resource aggregation: ${error}`);
+        await close().catch(() => undefined);
+        throw error;
     }
-    // Register prompts if available
+}
+/** Stdio-compatible owner: closing its downstream peer also closes its upstream snapshot. */
+export async function initializeMcpToolAggregationServer(serverConfigs, mcpTransport, serverName, serverVersion, strict) {
+    const host = await initializeMcpToolAggregationHost(serverConfigs, serverName, serverVersion, strict);
     try {
-        const allPrompts = await mcpManager.listAllPrompts();
-        logger.info(`Registering ${allPrompts.length} prompts from connected MCP servers`);
-        for (const promptName of allPrompts) {
-            mcpServer.prompt(promptName, `Prompt: ${promptName}`, async (extra) => {
-                logger.info(`Prompt aggregation: resolving ${promptName}`);
-                const promptArgs = extra && 'arguments' in extra
-                    ? extra.arguments
-                    : undefined;
-                return await mcpManager.getPrompt(promptName, promptArgs);
-            });
-        }
+        const server = await host.connect(mcpTransport);
+        server.close = host.close;
+        const previousClose = server.server.onclose;
+        server.server.onclose = () => {
+            try {
+                previousClose?.();
+            }
+            finally {
+                void host.close().catch(() => undefined);
+            }
+        };
+        return server;
     }
     catch (error) {
-        logger.debug(`Skipping prompt aggregation: ${error}`);
+        await host.close().catch(() => undefined);
+        throw error;
     }
-    // Connect server to transport
-    logger.info(`Connecting MCP tool aggregation server...`);
-    await mcpServer.connect(mcpTransport);
-    logger.info(`✅ MCP tool aggregation server connected with ${toolCount} tools exposed`);
-    return mcpServer;
 }

package/dist/api/server-hono.d.ts

@@ -3,6 +3,7 @@ import { DextoAgent } from '@dexto/core';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { createDextoApp, createNodeServer, type WebUIRuntimeConfig } from '@dexto/server';
 export type HonoInitializationResult = {
+    stop: () => Promise<void>;
     app: ReturnType<typeof createDextoApp>;
     server: ReturnType<typeof createNodeServer>['server'];
     webhookSubscriber?: NonNullable<ReturnType<typeof createNodeServer>['webhookSubscriber']>;
@@ -26,6 +27,7 @@ export type HonoInitializationResult = {
 export declare function initializeHonoApi(agent: DextoAgent, agentCardOverride?: Partial<AgentCard>, listenPort?: number, agentId?: string, configFilePath?: string, workspaceRoot?: string, webRoot?: string, webUIConfig?: WebUIRuntimeConfig): Promise<HonoInitializationResult>;
 export declare function startHonoApiServer(agent: DextoAgent, port?: number, agentCardOverride?: Partial<AgentCard>, agentId?: string, configFilePath?: string, workspaceRoot?: string, webRoot?: string, webUIConfig?: WebUIRuntimeConfig): Promise<{
     server: ReturnType<typeof createNodeServer>['server'];
+    stop: () => Promise<void>;
     webhookSubscriber?: NonNullable<ReturnType<typeof createNodeServer>['webhookSubscriber']>;
 }>;
 //# sourceMappingURL=server-hono.d.ts.map

package/dist/api/server-hono.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-hono.d.ts","sourceRoot":"","sources":["../../src/api/server-hono.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAuC,MAAM,aAAa,CAAC;AAY9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EACH,cAAc,EACd,gBAAgB,EAWhB,KAAK,kBAAkB,EAC1B,MAAM,eAAe,CAAC;AAmGvB,MAAM,MAAM,wBAAwB,GAAG;IACnC,GAAG,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IACvC,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtD,iBAAiB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC1F,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/E,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAGF,wBAAsB,iBAAiB,CACnC,KAAK,EAAE,UAAU,EACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,EACtC,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAiYnC;AAED,wBAAsB,kBAAkB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,SAAO,EACX,iBAAiB,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,EACtC,OAAO,CAAC,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC;IACP,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtD,iBAAiB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC;CAC7F,CAAC,CAkCD"}
+{"version":3,"file":"server-hono.d.ts","sourceRoot":"","sources":["../../src/api/server-hono.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAuC,MAAM,aAAa,CAAC;AAY9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EACH,cAAc,EACd,gBAAgB,EAWhB,KAAK,kBAAkB,EAC1B,MAAM,eAAe,CAAC;AAmGvB,MAAM,MAAM,wBAAwB,GAAG;IACnC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,GAAG,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IACvC,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtD,iBAAiB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC1F,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/E,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAGF,wBAAsB,iBAAiB,CACnC,KAAK,EAAE,UAAU,EACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,EACtC,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAsdnC;AAED,wBAAsB,kBAAkB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,SAAO,EACX,iBAAiB,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,EACtC,OAAO,CAAC,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC;IACP,MAAM,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC;IACtD,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,iBAAiB,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC;CAC7F,CAAC,CAkDD"}