@agiflowai/one-mcp 0.3.15 → 0.3.17

package/dist/{src-CWShQS8u.cjs → src-B8Rb84GQ.cjs}

@@ -1453,6 +1453,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
 */
@@ -1466,6 +1474,7 @@ var McpClient = class {
 	client;
 	childProcess;
 	connected = false;
+	reconnectFn;
 	constructor(serverName, transport, client, config) {
 		this.serverName = serverName;
 		this.serverInstruction = config.instruction;
@@ -1481,34 +1490,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() {
@@ -1524,23 +1575,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) {
@@ -1601,6 +1640,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 __modelcontextprotocol_sdk_client_index_js.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;
@@ -2808,7 +2861,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
@@ -2819,6 +2872,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
@@ -2922,7 +2976,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;
@@ -2995,13 +3055,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 __modelcontextprotocol_sdk_server_index_js.Server({
 		name: "@agiflowai/one-mcp",
 		version: "0.1.0"
@@ -3011,10 +3105,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(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => ({ tools: proxyMode === "flat" ? await (async () => {
 		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
@@ -3051,14 +3142,14 @@ async function createServer(options) {
 		throw new Error(`Unknown tool: ${name}`);
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.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,
@@ -3077,10 +3168,10 @@ async function createServer(options) {
 		return await (await clientManager.ensureConnected(matchingServers[0])).readResource(actualUri);
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.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, []);
@@ -3088,7 +3179,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;
@@ -3103,29 +3194,26 @@ async function createServer(options) {
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.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
@@ -4205,6 +4293,12 @@ Object.defineProperty(exports, 'createServer', {
     return createServer;
   }
 });
+Object.defineProperty(exports, 'createSessionServer', {
+  enumerable: true,
+  get: function () {
+    return createSessionServer;
+  }
+});
 Object.defineProperty(exports, 'findConfigFile', {
   enumerable: true,
   get: function () {
@@ -4217,6 +4311,12 @@ Object.defineProperty(exports, 'generateServerId', {
     return generateServerId;
   }
 });
+Object.defineProperty(exports, 'initializeSharedServices', {
+  enumerable: true,
+  get: function () {
+    return initializeSharedServices;
+  }
+});
 Object.defineProperty(exports, 'version', {
   enumerable: true,
   get: function () {