@agiflowai/one-mcp 0.3.15 → 0.3.17

package/dist/{src-CH93aUm2.mjs → src-D5YMjGgs.mjs}

@@ -1424,6 +1424,14 @@ var DefinitionsCacheService = class {
 /** Default connection timeout in milliseconds (30 seconds) */
 const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
 /**
+* Checks if an error is a session-related error from an HTTP backend
+* (e.g., downstream server restarted and no longer recognizes the session ID).
+*/
+function isSessionError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("unknown session") || message.includes("Session not found");
+}
+/**
 * MCP Client wrapper for managing individual server connections
 * This is an internal class used by McpClientManagerService
 */
@@ -1437,6 +1445,7 @@ var McpClient = class {
 	client;
 	childProcess;
 	connected = false;
+	reconnectFn;
 	constructor(serverName, transport, client, config) {
 		this.serverName = serverName;
 		this.serverInstruction = config.instruction;
@@ -1452,34 +1461,76 @@ var McpClient = class {
 	setConnected(connected) {
 		this.connected = connected;
 	}
+	/**
+	* Sets a reconnection function that creates a fresh Client and transport.
+	* Called automatically by withSessionRetry when a session error is detected
+	* (e.g., downstream HTTP server restarted and the old session ID is invalid).
+	*/
+	setReconnectFn(fn) {
+		this.reconnectFn = fn;
+	}
+	/**
+	* Wraps an operation with automatic retry on session errors.
+	* If the operation fails with a session error (e.g., downstream server restarted),
+	* reconnects and retries once.
+	*/
+	async withSessionRetry(operation) {
+		try {
+			return await operation();
+		} catch (error) {
+			if (!this.reconnectFn || !isSessionError(error)) throw error;
+			console.error(`Session error for ${this.serverName}, reconnecting: ${error instanceof Error ? error.message : String(error)}`);
+			try {
+				await this.client.close();
+			} catch (closeError) {
+				console.error(`Failed to close stale client for ${this.serverName}:`, closeError);
+			}
+			const result = await this.reconnectFn();
+			this.client = result.client;
+			if (result.childProcess) this.childProcess = result.childProcess;
+			return await operation();
+		}
+	}
 	async listTools() {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return (await this.client.listTools()).tools;
+		return this.withSessionRetry(async () => {
+			return (await this.client.listTools()).tools;
+		});
 	}
 	async listResources() {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return (await this.client.listResources()).resources;
+		return this.withSessionRetry(async () => {
+			return (await this.client.listResources()).resources;
+		});
 	}
 	async listPrompts() {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return (await this.client.listPrompts()).prompts;
+		return this.withSessionRetry(async () => {
+			return (await this.client.listPrompts()).prompts;
+		});
 	}
 	async callTool(name, args) {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return await this.client.callTool({
-			name,
-			arguments: args
+		return this.withSessionRetry(async () => {
+			return await this.client.callTool({
+				name,
+				arguments: args
+			});
 		});
 	}
 	async readResource(uri) {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return await this.client.readResource({ uri });
+		return this.withSessionRetry(async () => {
+			return await this.client.readResource({ uri });
+		});
 	}
 	async getPrompt(name, args) {
 		if (!this.connected) throw new Error(`Client for ${this.serverName} is not connected`);
-		return await this.client.getPrompt({
-			name,
-			arguments: args
+		return this.withSessionRetry(async () => {
+			return await this.client.getPrompt({
+				name,
+				arguments: args
+			});
 		});
 	}
 	async close() {
@@ -1495,23 +1546,11 @@ var McpClientManagerService = class {
 	clients = /* @__PURE__ */ new Map();
 	serverConfigs = /* @__PURE__ */ new Map();
 	connectionPromises = /* @__PURE__ */ new Map();
-	constructor() {
-		process.on("exit", () => {
-			this.cleanupOnExit();
-		});
-		process.on("SIGINT", () => {
-			this.cleanupOnExit();
-			process.exit(0);
-		});
-		process.on("SIGTERM", () => {
-			this.cleanupOnExit();
-			process.exit(0);
-		});
-	}
 	/**
-	* Cleanup all resources on exit (child processes)
+	* Synchronously kill all stdio MCP server child processes.
+	* Must be called by the owner (e.g. transport/command layer) during shutdown.
 	*/
-	cleanupOnExit() {
+	cleanupChildProcesses() {
 		for (const [serverName, client] of this.clients) try {
 			const childProcess = client["childProcess"];
 			if (childProcess && !childProcess.killed) {
@@ -1572,6 +1611,20 @@ var McpClientManagerService = class {
 		try {
 			await Promise.race([this.performConnection(mcpClient, config), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Connection timeout after ${timeoutMs}ms`)), timeoutMs))]);
 			mcpClient.setConnected(true);
+			if (config.transport === "http" || config.transport === "sse") mcpClient.setReconnectFn(async () => {
+				try {
+					const newClient = new Client({
+						name: "@agiflowai/one-mcp-client",
+						version: "0.1.0"
+					}, { capabilities: {} });
+					const newMcpClient = new McpClient(serverName, config.transport, newClient, {});
+					await this.performConnection(newMcpClient, config);
+					return { client: newClient };
+				} catch (error) {
+					console.error(`Failed to reconnect to ${serverName}:`, error);
+					throw error;
+				}
+			});
 			if (!mcpClient.serverInstruction) try {
 				const serverInstruction = mcpClient["client"].getInstructions();
 				if (serverInstruction) mcpClient.serverInstruction = serverInstruction;
@@ -2779,7 +2832,7 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 
 //#endregion
 //#region package.json
-var version = "0.3.14";
+var version = "0.3.16";
 
 //#endregion
 //#region src/server/index.ts
@@ -2790,6 +2843,7 @@ var version = "0.3.14";
 * - Factory pattern for server creation
 * - Tool registration pattern
 * - Dependency injection for services
+* - Shared services pattern for multi-session HTTP transport
 *
 * CODING STANDARDS:
 * - Register all tools, resources, and prompts here
@@ -2893,7 +2947,13 @@ function buildProxyInstructions(serverDefinitions, mode, includeSkillsTool) {
 		"Use describe_tools to inspect capabilities and use_tool to execute them."
 	].join("\n\n");
 }
-async function createServer(options) {
+/**
+* Initialize shared services and tools once for use across multiple sessions.
+* Use with createSessionServer() for HTTP transport where multiple agents
+* connect concurrently. This avoids duplicating downstream connections,
+* file watchers, caches, and tool instances per session.
+*/
+async function initializeSharedServices(options) {
 	const clientManager = new McpClientManagerService();
 	let configSkills;
 	let configId;
@@ -2966,13 +3026,47 @@ async function createServer(options) {
 		definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
 	}
 	else definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
+	const proxyMode = options?.proxyMode || "meta";
 	const describeTools = new DescribeToolsTool(clientManager, skillService, serverId, definitionsCacheService);
-	const useToolWithCache = new UseToolTool(clientManager, skillService, serverId, definitionsCacheService);
+	const useTool = new UseToolTool(clientManager, skillService, serverId, definitionsCacheService);
 	const searchListTools = new SearchListToolsTool(clientManager, definitionsCacheService);
 	toolsRef.describeTools = describeTools;
-	const serverDefinitions = await definitionsCacheService.getServerDefinitions();
-	const includeSkillsTool = await hasAnySkills(definitionsCacheService, skillService);
-	const proxyMode = options?.proxyMode || "meta";
+	if (skillService) skillService.startWatching().catch((error) => {
+		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);
+	});
+	if (!shouldStartFromCache && effectiveDefinitionsCachePath && options?.configFilePath) definitionsCacheService.collectForCache({
+		configPath: options.configFilePath,
+		configHash,
+		oneMcpVersion: version,
+		serverId
+	}).then((definitionsCache) => DefinitionsCacheService.writeToFile(effectiveDefinitionsCachePath, definitionsCache)).then(() => {
+		console.error(`[definitions-cache] Wrote ${effectiveDefinitionsCachePath}`);
+	}).catch((error) => {
+		console.error(`[definitions-cache] Failed to persist ${effectiveDefinitionsCachePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	});
+	const dispose = async () => {
+		await clientManager.disconnectAll();
+		if (skillService) skillService.stopWatching();
+	};
+	return {
+		clientManager,
+		definitionsCacheService,
+		skillService,
+		describeTools,
+		useTool,
+		searchListTools,
+		serverId,
+		proxyMode,
+		dispose
+	};
+}
+/**
+* Create a lightweight per-session MCP Server instance that delegates
+* to shared services and tools. Use with initializeSharedServices()
+* for multi-session HTTP transport.
+*/
+async function createSessionServer(shared) {
+	const { clientManager, definitionsCacheService, skillService, describeTools, useTool: useToolWithCache, searchListTools, serverId, proxyMode } = shared;
 	const server = new Server({
 		name: "@agiflowai/one-mcp",
 		version: "0.1.0"
@@ -2982,10 +3076,7 @@ async function createServer(options) {
 			resources: {},
 			prompts: {}
 		},
-		instructions: buildProxyInstructions(serverDefinitions, proxyMode, includeSkillsTool)
-	});
-	if (skillService) skillService.startWatching().catch((error) => {
-		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);
+		instructions: buildProxyInstructions(await definitionsCacheService.getServerDefinitions(), proxyMode, await hasAnySkills(definitionsCacheService, skillService))
 	});
 	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: proxyMode === "flat" ? await (async () => {
 		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
@@ -3022,14 +3113,14 @@ async function createServer(options) {
 		throw new Error(`Unknown tool: ${name}`);
 	});
 	server.setRequestHandler(ListResourcesRequestSchema, async () => {
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const resourceToServers = /* @__PURE__ */ new Map();
-		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+		for (const serverDefinition of currentServerDefinitions) for (const resource of serverDefinition.resources) {
 			if (!resourceToServers.has(resource.uri)) resourceToServers.set(resource.uri, []);
 			resourceToServers.get(resource.uri)?.push(serverDefinition.serverName);
 		}
 		const resources = [];
-		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+		for (const serverDefinition of currentServerDefinitions) for (const resource of serverDefinition.resources) {
 			const hasClash = (resourceToServers.get(resource.uri) || []).length > 1;
 			resources.push({
 				...resource,
@@ -3048,10 +3139,10 @@ async function createServer(options) {
 		return await (await clientManager.ensureConnected(matchingServers[0])).readResource(actualUri);
 	});
 	server.setRequestHandler(ListPromptsRequestSchema, async () => {
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const promptToServers = /* @__PURE__ */ new Map();
 		const serverPromptsMap = /* @__PURE__ */ new Map();
-		for (const serverDefinition of serverDefinitions$1) {
+		for (const serverDefinition of currentServerDefinitions) {
 			serverPromptsMap.set(serverDefinition.serverName, serverDefinition.prompts);
 			for (const prompt of serverDefinition.prompts) {
 				if (!promptToServers.has(prompt.name)) promptToServers.set(prompt.name, []);
@@ -3059,7 +3150,7 @@ async function createServer(options) {
 			}
 		}
 		const aggregatedPrompts = [];
-		for (const serverDefinition of serverDefinitions$1) {
+		for (const serverDefinition of currentServerDefinitions) {
 			const prompts = serverPromptsMap.get(serverDefinition.serverName) || [];
 			for (const prompt of prompts) {
 				const hasClash = (promptToServers.get(prompt.name) || []).length > 1;
@@ -3074,29 +3165,26 @@ async function createServer(options) {
 	});
 	server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const { serverName, actualToolName: actualPromptName } = parseToolName(name);
 		if (serverName) return await (await clientManager.ensureConnected(serverName)).getPrompt(actualPromptName, args);
 		const serversWithPrompt = [];
-		for (const serverDefinition of serverDefinitions$1) if (serverDefinition.prompts.some((prompt) => prompt.name === name)) serversWithPrompt.push(serverDefinition.serverName);
+		for (const serverDefinition of currentServerDefinitions) if (serverDefinition.prompts.some((prompt) => prompt.name === name)) serversWithPrompt.push(serverDefinition.serverName);
 		if (serversWithPrompt.length === 0) throw new Error(`Prompt not found: ${name}`);
 		if (serversWithPrompt.length > 1) throw new Error(`Prompt "${name}" exists on multiple servers: ${serversWithPrompt.join(", ")}. Use the prefixed format (e.g., "${serversWithPrompt[0]}__${name}") to specify which server to use.`);
 		const client = clientManager.getClient(serversWithPrompt[0]);
 		if (!client) return await (await clientManager.ensureConnected(serversWithPrompt[0])).getPrompt(name, args);
 		return await client.getPrompt(name, args);
 	});
-	if (!shouldStartFromCache && effectiveDefinitionsCachePath && options?.configFilePath) definitionsCacheService.collectForCache({
-		configPath: options.configFilePath,
-		configHash,
-		oneMcpVersion: version,
-		serverId
-	}).then((definitionsCache) => DefinitionsCacheService.writeToFile(effectiveDefinitionsCachePath, definitionsCache)).then(() => {
-		console.error(`[definitions-cache] Wrote ${effectiveDefinitionsCachePath}`);
-	}).catch((error) => {
-		console.error(`[definitions-cache] Failed to persist ${effectiveDefinitionsCachePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-	});
 	return server;
 }
+/**
+* Create a single MCP server instance (backward-compatible wrapper).
+* For multi-session HTTP transport, use initializeSharedServices() + createSessionServer() instead.
+*/
+async function createServer(options) {
+	return createSessionServer(await initializeSharedServices(options));
+}
 
 //#endregion
 //#region src/types/index.ts
@@ -4080,4 +4168,4 @@ var StopServerService = class {
 };
 
 //#endregion
-export { findConfigFile as _, SseTransportHandler as a, createServer as c, SearchListToolsTool as d, DescribeToolsTool as f, generateServerId as g, DefinitionsCacheService as h, StdioTransportHandler as i, version as l, McpClientManagerService as m, RuntimeStateService as n, HttpTransportHandler as o, SkillService as p, StdioHttpTransportHandler as r, TRANSPORT_MODE as s, StopServerService as t, UseToolTool as u, ConfigFetcherService as v };
+export { DefinitionsCacheService as _, SseTransportHandler as a, ConfigFetcherService as b, createServer as c, version as d, UseToolTool as f, McpClientManagerService as g, SkillService as h, StdioTransportHandler as i, createSessionServer as l, DescribeToolsTool as m, RuntimeStateService as n, HttpTransportHandler as o, SearchListToolsTool as p, StdioHttpTransportHandler as r, TRANSPORT_MODE as s, StopServerService as t, initializeSharedServices as u, generateServerId as v, findConfigFile as y };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agiflowai/one-mcp",
   "description": "One MCP server package",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "license": "AGPL-3.0",
   "keywords": [
     "mcp",