@agiflowai/one-mcp 0.3.15 → 0.3.16

package/dist/index.d.mts

@@ -406,160 +406,6 @@ interface Skill {
   basePath: string;
 }
 //#endregion
-//#region src/server/index.d.ts
-/**
- * Configuration options for creating an MCP server instance
- * @property configFilePath - Path to the MCP configuration file
- * @property noCache - Skip cache when fetching remote configuration
- * @property skills - Skills configuration with paths array (optional, skills disabled if not provided)
- * @property serverId - CLI-provided server ID (takes precedence over config file id)
- */
-interface ServerOptions {
-  configFilePath?: string;
-  noCache?: boolean;
-  skills?: {
-    paths: string[];
-  };
-  serverId?: string;
-  definitionsCachePath?: string;
-  clearDefinitionsCache?: boolean;
-  proxyMode?: 'meta' | 'flat' | 'search';
-  onServerIdResolved?: (serverId: string) => Promise<void> | void;
-}
-declare function createServer(options?: ServerOptions): Promise<Server>;
-//#endregion
-//#region src/transports/http.d.ts
-/**
- * HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
- * Provides stateful session management with resumability support
- */
-declare class HttpTransportHandler implements HttpTransportHandler$1 {
-  private serverFactory;
-  private app;
-  private server;
-  private sessionManager;
-  private config;
-  private adminOptions?;
-  private adminRateLimiter;
-  constructor(serverFactory: (() => Server | Promise<Server>), config: TransportConfig, adminOptions?: HttpTransportAdminOptions);
-  private setupMiddleware;
-  private setupRoutes;
-  private isAuthorizedShutdownRequest;
-  private handleAdminShutdownRequest;
-  private handlePostRequest;
-  private handleGetRequest;
-  private handleDeleteRequest;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  getPort(): number;
-  getHost(): string;
-}
-//#endregion
-//#region src/transports/sse.d.ts
-/**
- * SSE (Server-Sent Events) transport handler
- * Legacy transport for backwards compatibility (protocol version 2024-11-05)
- * Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
- */
-declare class SseTransportHandler implements HttpTransportHandler$1 {
-  private serverFactory;
-  private app;
-  private server;
-  private sessionManager;
-  private config;
-  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
-  private setupMiddleware;
-  private setupRoutes;
-  private handleSseConnection;
-  private handlePostMessage;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  getPort(): number;
-  getHost(): string;
-}
-//#endregion
-//#region src/transports/stdio.d.ts
-/**
- * Stdio transport handler for MCP server
- * Used for command-line and direct integrations
- */
-declare class StdioTransportHandler implements TransportHandler {
-  private server;
-  private transport;
-  constructor(server: Server);
-  start(): Promise<void>;
-  stop(): Promise<void>;
-}
-//#endregion
-//#region src/transports/stdio-http.d.ts
-interface StdioHttpProxyTransportConfig {
-  endpoint: URL;
-}
-/**
- * Transport that serves MCP over stdio and forwards MCP requests to an HTTP endpoint.
- */
-declare class StdioHttpTransportHandler implements TransportHandler {
-  private readonly endpoint;
-  private stdioProxyServer;
-  private stdioTransport;
-  private httpClient;
-  constructor(config: StdioHttpProxyTransportConfig);
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  private createProxyServer;
-}
-//#endregion
-//#region src/services/McpClientManagerService.d.ts
-/**
- * Service for managing MCP client connections to remote servers
- */
-declare class McpClientManagerService {
-  private clients;
-  private serverConfigs;
-  private connectionPromises;
-  constructor();
-  /**
-   * Cleanup all resources on exit (child processes)
-   */
-  private cleanupOnExit;
-  /**
-   * Connect to an MCP server based on its configuration with timeout
-   * Uses the timeout from server config, falling back to default (30s)
-   */
-  connectToServer(serverName: string, config: McpServerConfig): Promise<void>;
-  registerServerConfigs(configs: Record<string, McpServerConfig>): void;
-  getKnownServerNames(): string[];
-  ensureConnected(serverName: string): Promise<McpClientConnection>;
-  private createConnection;
-  /**
-   * Perform the actual connection to MCP server
-   */
-  private performConnection;
-  private connectStdioClient;
-  private connectHttpClient;
-  private connectSseClient;
-  /**
-   * Get a connected client by server name
-   */
-  getClient(serverName: string): McpClientConnection | undefined;
-  /**
-   * Get all connected clients
-   */
-  getAllClients(): McpClientConnection[];
-  /**
-   * Disconnect from a specific server
-   */
-  disconnectServer(serverName: string): Promise<void>;
-  /**
-   * Disconnect from all servers
-   */
-  disconnectAll(): Promise<void>;
-  /**
-   * Check if a server is connected
-   */
-  isConnected(serverName: string): boolean;
-}
-//#endregion
 //#region src/services/SkillService.d.ts
 /**
  * Service for loading and managing skills from configured skill directories.
@@ -687,6 +533,57 @@ declare class SkillService {
   private loadSkillFile;
 }
 //#endregion
+//#region src/services/McpClientManagerService.d.ts
+/**
+ * Service for managing MCP client connections to remote servers
+ */
+declare class McpClientManagerService {
+  private clients;
+  private serverConfigs;
+  private connectionPromises;
+  /**
+   * Synchronously kill all stdio MCP server child processes.
+   * Must be called by the owner (e.g. transport/command layer) during shutdown.
+   */
+  cleanupChildProcesses(): void;
+  /**
+   * Connect to an MCP server based on its configuration with timeout
+   * Uses the timeout from server config, falling back to default (30s)
+   */
+  connectToServer(serverName: string, config: McpServerConfig): Promise<void>;
+  registerServerConfigs(configs: Record<string, McpServerConfig>): void;
+  getKnownServerNames(): string[];
+  ensureConnected(serverName: string): Promise<McpClientConnection>;
+  private createConnection;
+  /**
+   * Perform the actual connection to MCP server
+   */
+  private performConnection;
+  private connectStdioClient;
+  private connectHttpClient;
+  private connectSseClient;
+  /**
+   * Get a connected client by server name
+   */
+  getClient(serverName: string): McpClientConnection | undefined;
+  /**
+   * Get all connected clients
+   */
+  getAllClients(): McpClientConnection[];
+  /**
+   * Disconnect from a specific server
+   */
+  disconnectServer(serverName: string): Promise<void>;
+  /**
+   * Disconnect from all servers
+   */
+  disconnectAll(): Promise<void>;
+  /**
+   * Check if a server is connected
+   */
+  isConnected(serverName: string): boolean;
+}
+//#endregion
 //#region src/services/DefinitionsCacheService.d.ts
 interface DefinitionsCacheServiceOptions {
   cacheData?: DefinitionsCacheFile;
@@ -970,6 +867,147 @@ declare class UseToolTool implements Tool<UseToolToolInput> {
   execute(input: UseToolToolInput): Promise<CallToolResult>;
 }
 //#endregion
+//#region src/server/index.d.ts
+/**
+ * Configuration options for creating an MCP server instance
+ * @property configFilePath - Path to the MCP configuration file
+ * @property noCache - Skip cache when fetching remote configuration
+ * @property skills - Skills configuration with paths array (optional, skills disabled if not provided)
+ * @property serverId - CLI-provided server ID (takes precedence over config file id)
+ */
+interface ServerOptions {
+  configFilePath?: string;
+  noCache?: boolean;
+  skills?: {
+    paths: string[];
+  };
+  serverId?: string;
+  definitionsCachePath?: string;
+  clearDefinitionsCache?: boolean;
+  proxyMode?: 'meta' | 'flat' | 'search';
+  onServerIdResolved?: (serverId: string) => Promise<void> | void;
+}
+/**
+ * Shared services and tools for multi-session HTTP transport.
+ * Created once via initializeSharedServices(), then passed to createSessionServer()
+ * for each new client session. This avoids duplicating downstream connections,
+ * file watchers, and caches across concurrent sessions.
+ */
+interface SharedServices {
+  clientManager: McpClientManagerService;
+  definitionsCacheService: DefinitionsCacheService;
+  skillService?: SkillService;
+  describeTools: DescribeToolsTool;
+  useTool: UseToolTool;
+  searchListTools: SearchListToolsTool;
+  serverId: string;
+  proxyMode: 'meta' | 'flat' | 'search';
+  /**
+   * Disposes all shared resources: disconnects downstream servers,
+   * stops file watchers. Must be called by the owner on shutdown.
+   */
+  dispose: () => Promise<void>;
+}
+/**
+ * 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.
+ */
+declare function initializeSharedServices(options?: ServerOptions): Promise<SharedServices>;
+/**
+ * Create a lightweight per-session MCP Server instance that delegates
+ * to shared services and tools. Use with initializeSharedServices()
+ * for multi-session HTTP transport.
+ */
+declare function createSessionServer(shared: SharedServices): Promise<Server>;
+/**
+ * Create a single MCP server instance (backward-compatible wrapper).
+ * For multi-session HTTP transport, use initializeSharedServices() + createSessionServer() instead.
+ */
+declare function createServer(options?: ServerOptions): Promise<Server>;
+//#endregion
+//#region src/transports/http.d.ts
+/**
+ * HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+ * Provides stateful session management with resumability support
+ */
+declare class HttpTransportHandler implements HttpTransportHandler$1 {
+  private serverFactory;
+  private app;
+  private server;
+  private sessionManager;
+  private config;
+  private adminOptions?;
+  private adminRateLimiter;
+  constructor(serverFactory: (() => Server | Promise<Server>), config: TransportConfig, adminOptions?: HttpTransportAdminOptions);
+  private setupMiddleware;
+  private setupRoutes;
+  private isAuthorizedShutdownRequest;
+  private handleAdminShutdownRequest;
+  private handlePostRequest;
+  private handleGetRequest;
+  private handleDeleteRequest;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getPort(): number;
+  getHost(): string;
+}
+//#endregion
+//#region src/transports/sse.d.ts
+/**
+ * SSE (Server-Sent Events) transport handler
+ * Legacy transport for backwards compatibility (protocol version 2024-11-05)
+ * Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+ */
+declare class SseTransportHandler implements HttpTransportHandler$1 {
+  private serverFactory;
+  private app;
+  private server;
+  private sessionManager;
+  private config;
+  constructor(serverFactory: Server | (() => Server), config: TransportConfig);
+  private setupMiddleware;
+  private setupRoutes;
+  private handleSseConnection;
+  private handlePostMessage;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getPort(): number;
+  getHost(): string;
+}
+//#endregion
+//#region src/transports/stdio.d.ts
+/**
+ * Stdio transport handler for MCP server
+ * Used for command-line and direct integrations
+ */
+declare class StdioTransportHandler implements TransportHandler {
+  private server;
+  private transport;
+  constructor(server: Server);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/transports/stdio-http.d.ts
+interface StdioHttpProxyTransportConfig {
+  endpoint: URL;
+}
+/**
+ * Transport that serves MCP over stdio and forwards MCP requests to an HTTP endpoint.
+ */
+declare class StdioHttpTransportHandler implements TransportHandler {
+  private readonly endpoint;
+  private stdioProxyServer;
+  private stdioTransport;
+  private httpClient;
+  constructor(config: StdioHttpProxyTransportConfig);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  private createProxyServer;
+}
+//#endregion
 //#region src/services/ConfigFetcherService.d.ts
 interface ConfigFetcherOptions {
   configFilePath?: string;
@@ -1238,4 +1276,4 @@ declare function findConfigFile(): string | null;
  */
 declare function generateServerId(length?: number): string;
 //#endregion
-export { CachedFileSkillInfo, CachedPromptSkillInfo, CachedServerDefinition, ConfigFetcherService, DefinitionsCacheFile, DefinitionsCacheService, DescribeToolsTool, HttpTransportAdminOptions, HttpTransportHandler, HttpTransportHealthResponse, HttpTransportShutdownResponse, McpClientConnection, McpClientManagerService, McpHttpConfig, McpPromptInfo, McpResourceInfo, McpServerConfig, McpServerTransportConfig, McpServerTransportType, McpSseConfig, McpStdioConfig, McpToolInfo, PromptConfig, PromptSkillConfig, RemoteMcpConfiguration, RuntimeLookupOptions, RuntimeStateManager, RuntimeStateRecord, RuntimeStateService, SearchListToolsTool, type ServerOptions, Skill, SkillMetadata, SkillService, SkillsConfig, SseTransportHandler, StdioHttpTransportHandler, StdioTransportHandler, type StopServerRequest, type StopServerResult, StopServerService, TRANSPORT_MODE, Tool, ToolDefinition, TransportConfig, TransportHandler, TransportMode, UseToolTool, createServer, findConfigFile, generateServerId };
+export { CachedFileSkillInfo, CachedPromptSkillInfo, CachedServerDefinition, ConfigFetcherService, DefinitionsCacheFile, DefinitionsCacheService, DescribeToolsTool, HttpTransportAdminOptions, HttpTransportHandler, HttpTransportHealthResponse, HttpTransportShutdownResponse, McpClientConnection, McpClientManagerService, McpHttpConfig, McpPromptInfo, McpResourceInfo, McpServerConfig, McpServerTransportConfig, McpServerTransportType, McpSseConfig, McpStdioConfig, McpToolInfo, PromptConfig, PromptSkillConfig, RemoteMcpConfiguration, RuntimeLookupOptions, RuntimeStateManager, RuntimeStateRecord, RuntimeStateService, SearchListToolsTool, type ServerOptions, type SharedServices, Skill, SkillMetadata, SkillService, SkillsConfig, SseTransportHandler, StdioHttpTransportHandler, StdioTransportHandler, type StopServerRequest, type StopServerResult, StopServerService, TRANSPORT_MODE, Tool, ToolDefinition, TransportConfig, TransportHandler, TransportMode, UseToolTool, createServer, createSessionServer, findConfigFile, generateServerId, initializeSharedServices };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { _ as findConfigFile, a as SseTransportHandler, c as createServer, d as SearchListToolsTool, f as DescribeToolsTool, g as generateServerId, h as DefinitionsCacheService, i as StdioTransportHandler, m as McpClientManagerService, n as RuntimeStateService, o as HttpTransportHandler, p as SkillService, r as StdioHttpTransportHandler, s as TRANSPORT_MODE, t as StopServerService, u as UseToolTool, v as ConfigFetcherService } from "./src-CH93aUm2.mjs";
+import { _ as DefinitionsCacheService, a as SseTransportHandler, b as ConfigFetcherService, c as createServer, f as UseToolTool, g as McpClientManagerService, h as SkillService, i as StdioTransportHandler, l as createSessionServer, m as DescribeToolsTool, n as RuntimeStateService, o as HttpTransportHandler, p as SearchListToolsTool, r as StdioHttpTransportHandler, s as TRANSPORT_MODE, t as StopServerService, u as initializeSharedServices, v as generateServerId, y as findConfigFile } from "./src-Dn6vMZIk.mjs";
 
-export { ConfigFetcherService, DefinitionsCacheService, DescribeToolsTool, HttpTransportHandler, McpClientManagerService, RuntimeStateService, SearchListToolsTool, SkillService, SseTransportHandler, StdioHttpTransportHandler, StdioTransportHandler, StopServerService, TRANSPORT_MODE, UseToolTool, createServer, findConfigFile, generateServerId };
+export { ConfigFetcherService, DefinitionsCacheService, DescribeToolsTool, HttpTransportHandler, McpClientManagerService, RuntimeStateService, SearchListToolsTool, SkillService, SseTransportHandler, StdioHttpTransportHandler, StdioTransportHandler, StopServerService, TRANSPORT_MODE, UseToolTool, createServer, createSessionServer, findConfigFile, generateServerId, initializeSharedServices };

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

@@ -1524,23 +1524,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) {
@@ -2808,7 +2796,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.15";
 
 //#endregion
 //#region src/server/index.ts
@@ -2819,6 +2807,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 +2911,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 +2990,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 +3040,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 +3077,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 +3103,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 +3114,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 +3129,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 +4228,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 +4246,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 () {