@skilder-ai/runtime 0.7.4 → 0.7.5

package/dist/index.js

@@ -138392,6 +138392,7 @@ var McpServerStatus = /* @__PURE__ */ ((McpServerStatus2) => {
   McpServerStatus2["Connected"] = "CONNECTED";
   McpServerStatus2["Disconnected"] = "DISCONNECTED";
   McpServerStatus2["Error"] = "ERROR";
+  McpServerStatus2["Idle"] = "IDLE";
   McpServerStatus2["Pending"] = "PENDING";
   McpServerStatus2["Starting"] = "STARTING";
   return McpServerStatus2;
@@ -152624,10 +152625,29 @@ var ToolService = class ToolService2 extends Service {
     this.rxSubscriptions = [];
     this.sdkBundleContent = null;
     this.sdkBundleLoadPromise = null;
+    this.dormantConfigs = /* @__PURE__ */ new Map();
+    this.idleTimers = /* @__PURE__ */ new Map();
+    this.startingServers = /* @__PURE__ */ new Map();
+    this.stoppingServers = /* @__PURE__ */ new Map();
+    this.activationFailures = /* @__PURE__ */ new Map();
+    this.maxActivationRetries = 3;
+    this.activationCooldownMs = 6e4;
+    this.lazyStartEnabled = true;
+    this.idleTimeoutMs = 3e5;
     this.logger = this.loggerService.getLogger(this.name);
   }
   async initialize() {
     this.logger.info("Starting");
+    const lazyStartRaw = (process.env.MCP_LAZY_START ?? "true").toLowerCase();
+    this.lazyStartEnabled = !["false", "0", "no", "off"].includes(lazyStartRaw);
+    const parsedTimeout = parseInt(process.env.MCP_IDLE_TIMEOUT_MS ?? "300000", 10);
+    if (Number.isNaN(parsedTimeout) || parsedTimeout <= 0) {
+      this.logger.warn({ rawValue: process.env.MCP_IDLE_TIMEOUT_MS }, "Invalid MCP_IDLE_TIMEOUT_MS value, falling back to default 300000ms");
+      this.idleTimeoutMs = 3e5;
+    } else {
+      this.idleTimeoutMs = parsedTimeout;
+    }
+    this.logger.info({ lazyStart: this.lazyStartEnabled, idleTimeoutMs: this.idleTimeoutMs }, "Lazy-start configuration");
     await this.authService.waitForStarted();
     await this.natsService.waitForStarted();
     await this.healthService.waitForStarted();
@@ -152662,7 +152682,7 @@ var ToolService = class ToolService2 extends Service {
       this.natsService.publish(message);
       this.logger.debug(`Published MCP server status: ${mcpServerId} -> ${status}${error48 ? ` (${error48})` : ""}`);
     } catch (publishError) {
-      this.logger.error(`Failed to publish MCP server status ${mcpServerId} -> ${status}: ${publishError}`);
+      this.logger.error({ mcpServerId, status, err: publishError }, "Failed to publish MCP server status");
     }
   }
   async shutdown() {
@@ -152693,19 +152713,25 @@ var ToolService = class ToolService2 extends Service {
         this.logger.debug(`Processing MCP Servers update with ${msg.data.mcpServers.length} MCP Servers`);
         this.roots = msg.data.roots;
         const mcpServerIds = msg.data.mcpServers.map((mcpServer) => mcpServer.id);
-        const mcpServersToStop = Array.from(this.mcpServers.keys()).filter((mcpServerId) => !mcpServerIds.includes(mcpServerId));
-        for (const mcpServerId of mcpServersToStop) {
+        const runningToStop = Array.from(this.mcpServers.keys()).filter((id) => !mcpServerIds.includes(id));
+        const dormantToRemove = Array.from(this.dormantConfigs.keys()).filter((id) => !mcpServerIds.includes(id));
+        for (const mcpServerId of runningToStop) {
           const service = this.mcpServers.get(mcpServerId);
           await this.stopMCPServer({ id: mcpServerId, name: service.getName() });
         }
+        for (const mcpServerId of dormantToRemove) {
+          this.removeDormantServer(mcpServerId);
+        }
         for (const mcpServer of msg.data.mcpServers) {
-          await this.spawnMCPServer(mcpServer).catch(async (error48) => {
-            this.logger.error(`Failed to spawn MCP Server ${mcpServer.name}: ${error48}`);
+          await this.registerMCPServer(mcpServer).catch(async (error48) => {
+            this.logger.error({ mcpServerId: mcpServer.id, mcpServerName: mcpServer.name, err: error48 }, "Failed to register MCP Server");
+            this.publishMCPServerStatus(mcpServer.workspace?.id, mcpServer.id, "ERROR", error48 instanceof Error ? error48.message : String(error48));
             const service = this.mcpServers.get(mcpServer.id);
             if (service) {
               await this.stopService(service);
             }
             this.mcpServers.delete(mcpServer.id);
+            this.removeDormantServer(mcpServer.id);
           });
         }
       }
@@ -152733,6 +152759,13 @@ var ToolService = class ToolService2 extends Service {
       }
       this.cacheSubscriptions = [];
     }
+    if (this.startingServers.size > 0 || this.stoppingServers.size > 0) {
+      this.logger.debug({ starting: this.startingServers.size, stopping: this.stoppingServers.size }, "Waiting for in-flight MCP server activations/stops to settle");
+      await Promise.allSettled([
+        ...Array.from(this.startingServers.values()),
+        ...Array.from(this.stoppingServers.values())
+      ]);
+    }
     const serverIds = Array.from(this.mcpServers.keys());
     for (const mcpServerId of serverIds) {
       const service = this.mcpServers.get(mcpServerId);
@@ -152740,20 +152773,76 @@ var ToolService = class ToolService2 extends Service {
         continue;
       await this.stopMCPServer({ id: mcpServerId, name: service.getName() });
     }
+    for (const mcpServerId of Array.from(this.dormantConfigs.keys())) {
+      this.removeDormantServer(mcpServerId);
+    }
+    for (const timer of this.idleTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.idleTimers.clear();
   }
   /**
-   * Spawn an MCP Server
-   * - the mcpServer argument contains the list of tools and capabilities that the MCP Server advertises
+   * Register an MCP Server. For STDIO servers with lazy-start enabled, the server is registered
+   * as dormant (config stored, NATS tool subscriptions active, no subprocess spawned).
+   * For non-STDIO servers or when lazy-start is disabled, the server is activated immediately.
    */
-  async spawnMCPServer(mcpServer) {
+  async registerMCPServer(mcpServer) {
     const roots = this.getRoots();
-    const existingMcpServer = this.mcpServers.get(mcpServer.id);
-    if (existingMcpServer && getConfigSignature(existingMcpServer.getConfig(), existingMcpServer.getRoots()) === getConfigSignature(mcpServer, roots)) {
-      this.logger.debug(`MCPServer ${mcpServer.name} already running -> skipping spawn`);
-      const tools2 = mcpServer.tools ?? [];
-      this.ensureToolsSubscribed(mcpServer.id, tools2);
+    const newSignature = getConfigSignature(mcpServer, roots);
+    const existingRunning = this.mcpServers.get(mcpServer.id);
+    if (existingRunning && getConfigSignature(existingRunning.getConfig(), existingRunning.getRoots()) === newSignature) {
+      this.logger.debug(`MCPServer ${mcpServer.name} already running -> skipping`);
+      this.ensureToolsSubscribed(mcpServer.id, mcpServer.tools ?? []);
+      return;
+    }
+    const existingDormant = this.dormantConfigs.get(mcpServer.id);
+    if (existingDormant && existingDormant.configSignature === newSignature) {
+      this.logger.debug(`MCPServer ${mcpServer.name} already dormant with same config -> skipping`);
+      this.ensureToolsSubscribed(mcpServer.id, mcpServer.tools ?? []);
+      return;
+    }
+    if (existingRunning) {
+      this.logger.debug(`MCPServer ${mcpServer.name} config changed -> stopping`);
+      await this.stopMCPServer(mcpServer);
+    }
+    if (existingDormant) {
+      this.dormantConfigs.delete(mcpServer.id);
+    }
+    this.activationFailures.delete(mcpServer.id);
+    const isStdio = mcpServer.transport === dgraph_resolvers_types_exports.McpTransportType.Stdio;
+    const hasKnownTools = (mcpServer.tools?.length ?? 0) > 0;
+    if (this.lazyStartEnabled && isStdio && hasKnownTools) {
+      this.logger.info(`Registering MCPServer ${mcpServer.name} as dormant (lazy-start)`);
+      this.dormantConfigs.set(mcpServer.id, { config: mcpServer, configSignature: newSignature });
+      if (mcpServer.workspace?.id) {
+        this.mcpServerWorkspaces.set(mcpServer.id, mcpServer.workspace.id);
+      }
+      this.ensureToolsSubscribed(mcpServer.id, mcpServer.tools ?? []);
+      this.publishMCPServerStatus(mcpServer.workspace?.id, mcpServer.id, "IDLE");
       return;
     }
+    if (this.lazyStartEnabled && isStdio && !hasKnownTools) {
+      this.logger.info(`MCPServer ${mcpServer.name} has no known tools -> activating eagerly for tool discovery`);
+    }
+    await this.activateMCPServer(mcpServer);
+  }
+  /**
+   * Activate an MCP Server: spawn the subprocess, connect, and start observing tools.
+   * Can be called eagerly (from registerMCPServer) or on-demand (from ensureServerActive).
+   */
+  async activateMCPServer(mcpServerOrId) {
+    let mcpServer;
+    let isDormantActivation = false;
+    if (typeof mcpServerOrId === "string") {
+      const dormant = this.dormantConfigs.get(mcpServerOrId);
+      if (!dormant)
+        throw new Error(`No dormant config found for MCP Server ${mcpServerOrId}`);
+      mcpServer = dormant.config;
+      isDormantActivation = true;
+    } else {
+      mcpServer = mcpServerOrId;
+    }
+    const roots = this.getRoots();
     let authProvider;
     if (mcpServer.oauthProvider === "MCP_OAUTH") {
       const identity = this.authService.getIdentity();
@@ -152786,7 +152875,7 @@ var ToolService = class ToolService2 extends Service {
       }
     }
     const mcpServerService = this.toolServerServiceFactory(mcpServer, roots, authProvider);
-    this.logger.info(`Spawning MCPServer: ${mcpServer.name} with ${mcpServer.tools?.length ?? 0} tools, and roots: ${JSON.stringify(roots)}`);
+    this.logger.info(`Activating MCPServer: ${mcpServer.name} with ${mcpServer.tools?.length ?? 0} tools, and roots: ${JSON.stringify(roots)}`);
     if (this.mcpServers.has(mcpServer.id)) {
       this.logger.debug(`MCPServer ${mcpServer.name} already running -> shutting down`);
       await this.stopMCPServer(mcpServer);
@@ -152804,11 +152893,32 @@ var ToolService = class ToolService2 extends Service {
       this.mcpServerWorkspaces.delete(mcpServer.id);
       throw error48;
     }
+    if (isDormantActivation) {
+      this.dormantConfigs.delete(mcpServer.id);
+    }
     let hasPublishedConnected = false;
     mcpServerService.observeTools().subscribe({
       error: (err) => {
-        this.logger.error(`Tools observable error for MCP Server ${mcpServer.id}: ${err}`);
+        this.logger.error({ mcpServerId: mcpServer.id, err }, "Tools observable error for MCP Server");
         this.publishMCPServerStatus(mcpServer.workspace?.id, mcpServer.id, "ERROR", err instanceof Error ? err.message : String(err));
+        this.mcpServers.delete(mcpServer.id);
+        this.mcpTools.delete(mcpServer.id);
+        const idleTimer = this.idleTimers.get(mcpServer.id);
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+          this.idleTimers.delete(mcpServer.id);
+        }
+        const stopPromise = this.stopService(mcpServerService).catch((stopErr) => this.logger.error({ mcpServerId: mcpServer.id, err: stopErr }, "Failed to stop errored MCP server")).then(() => {
+          this.stoppingServers.delete(mcpServer.id);
+          if (this.lazyStartEnabled && mcpServer.transport === dgraph_resolvers_types_exports.McpTransportType.Stdio) {
+            this.dormantConfigs.set(mcpServer.id, {
+              config: mcpServer,
+              configSignature: getConfigSignature(mcpServer, roots)
+            });
+            this.publishMCPServerStatus(mcpServer.workspace?.id, mcpServer.id, "IDLE");
+          }
+        });
+        this.stoppingServers.set(mcpServer.id, stopPromise);
       },
       next: (tools2) => {
         this.logger.debug(`Updating tools for MCP Server ${mcpServer.id} with ${tools2.length} tools`);
@@ -152829,13 +152939,119 @@ var ToolService = class ToolService2 extends Service {
           });
           this.natsService.publish(message);
         } catch (publishError) {
-          this.logger.warn(`Failed to publish discovered tools for ${mcpServer.id}: ${publishError}`);
+          this.logger.error({ mcpServerId: mcpServer.id, err: publishError }, "Failed to publish discovered tools \u2014 backend may show stale tool list");
         }
       }
     });
     const tools = mcpServer.tools ?? [];
     this.ensureToolsSubscribed(mcpServer.id, tools);
-    this.logger.info(`MCPServer ${mcpServer.name} spawned`);
+    if (this.lazyStartEnabled && mcpServer.transport === dgraph_resolvers_types_exports.McpTransportType.Stdio) {
+      this.resetIdleTimer(mcpServer.id);
+    }
+    this.logger.info(`MCPServer ${mcpServer.name} activated`);
+    return mcpServerService;
+  }
+  /**
+   * Ensure a dormant server is activated, deduplicating concurrent activation requests.
+   * Waits for any in-flight stop to complete before re-activating.
+   */
+  async ensureServerActive(mcpServerId) {
+    const existing = this.startingServers.get(mcpServerId);
+    if (existing)
+      return existing;
+    const stopping = this.stoppingServers.get(mcpServerId);
+    if (stopping) {
+      await stopping;
+    }
+    const promise2 = this.activateMCPServer(mcpServerId);
+    this.startingServers.set(mcpServerId, promise2);
+    try {
+      const service = await promise2;
+      if (!this.mcpServers.has(mcpServerId)) {
+        throw new Error(`MCP server ${mcpServerId} was deregistered during activation`);
+      }
+      return service;
+    } finally {
+      this.startingServers.delete(mcpServerId);
+    }
+  }
+  /**
+   * Reset the idle timer for a lazy-started server.
+   */
+  resetIdleTimer(mcpServerId) {
+    const existing = this.idleTimers.get(mcpServerId);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.idleShutdown(mcpServerId).catch((err) => this.logger.error({ mcpServerId, err }, "Idle shutdown failed"));
+    }, this.idleTimeoutMs);
+    this.idleTimers.set(mcpServerId, timer);
+  }
+  /**
+   * Shut down an idle MCP server and move it back to dormant state.
+   * NATS tool subscriptions and mcpTools are kept alive for on-demand re-activation.
+   */
+  async idleShutdown(mcpServerId) {
+    if (this.startingServers.has(mcpServerId)) {
+      this.resetIdleTimer(mcpServerId);
+      return;
+    }
+    const server = this.mcpServers.get(mcpServerId);
+    if (!server) {
+      this.logger.debug({ mcpServerId }, "Idle timer fired for server not in mcpServers map, ignoring");
+      this.idleTimers.delete(mcpServerId);
+      return;
+    }
+    const config2 = server.getConfig();
+    const roots = server.getRoots();
+    this.logger.info(`Idle shutdown for MCP server ${config2.name}`);
+    try {
+      await this.stopService(server);
+    } catch (err) {
+      this.logger.error({ mcpServerId, err }, "Error stopping service during idle shutdown");
+      this.mcpServers.delete(mcpServerId);
+      this.idleTimers.delete(mcpServerId);
+      this.dormantConfigs.set(mcpServerId, {
+        config: config2,
+        configSignature: getConfigSignature(config2, roots)
+      });
+      const workspaceId2 = this.mcpServerWorkspaces.get(mcpServerId);
+      this.publishMCPServerStatus(workspaceId2, mcpServerId, "IDLE");
+      return;
+    }
+    this.mcpServers.delete(mcpServerId);
+    this.dormantConfigs.set(mcpServerId, {
+      config: config2,
+      configSignature: getConfigSignature(config2, roots)
+    });
+    const workspaceId = this.mcpServerWorkspaces.get(mcpServerId);
+    this.publishMCPServerStatus(workspaceId, mcpServerId, "IDLE");
+    this.idleTimers.delete(mcpServerId);
+  }
+  /**
+   * Remove a dormant server completely: clean up NATS tool subscriptions, mcpTools, and config.
+   */
+  removeDormantServer(mcpServerId) {
+    this.dormantConfigs.delete(mcpServerId);
+    this.activationFailures.delete(mcpServerId);
+    const serverToolSubs = this.toolSubscriptions.get(mcpServerId);
+    if (serverToolSubs) {
+      for (const [toolId, subscription] of serverToolSubs.entries()) {
+        try {
+          subscription.unsubscribe();
+        } catch (error48) {
+          this.logger.warn({ toolId, err: error48 }, "Failed to unsubscribe dormant tool");
+        }
+      }
+      this.toolSubscriptions.delete(mcpServerId);
+    }
+    this.mcpTools.delete(mcpServerId);
+    this.mcpServerWorkspaces.delete(mcpServerId);
+    const timer = this.idleTimers.get(mcpServerId);
+    if (timer) {
+      clearTimeout(timer);
+      this.idleTimers.delete(mcpServerId);
+    }
   }
   // Subscribe to a tool and return the subscription
   subscribeToTool(tool2) {
@@ -152897,11 +153113,45 @@ var ToolService = class ToolService2 extends Service {
             continue;
           }
           this.logger.debug(`Found tool ${tool2.name} in MCP Server ${mcpServerId}`);
-          const mcpServer = this.mcpServers.get(mcpServerId);
+          let mcpServer = this.mcpServers.get(mcpServerId);
+          if (!mcpServer && this.dormantConfigs.has(mcpServerId)) {
+            const failures = this.activationFailures.get(mcpServerId);
+            if (failures && failures.count >= this.maxActivationRetries) {
+              const elapsed = Date.now() - failures.lastAttempt;
+              if (elapsed < this.activationCooldownMs) {
+                const retryInSec = Math.ceil((this.activationCooldownMs - elapsed) / 1e3);
+                msg.respond(new ErrorResponse({
+                  error: `MCP server failed to start after ${failures.count} attempts. Will retry in ${retryInSec}s.`
+                }));
+                toolCalled = true;
+                continue;
+              }
+              this.activationFailures.delete(mcpServerId);
+            }
+            this.logger.info(`Activating dormant MCP server ${mcpServerId} for tool call`);
+            try {
+              mcpServer = await this.ensureServerActive(mcpServerId);
+              this.activationFailures.delete(mcpServerId);
+            } catch (activationError) {
+              const prev = this.activationFailures.get(mcpServerId);
+              this.activationFailures.set(mcpServerId, {
+                count: (prev?.count ?? 0) + 1,
+                lastAttempt: Date.now()
+              });
+              this.logger.error({ mcpServerId, err: activationError }, "Failed to activate dormant MCP server");
+              const userMessage = activationError instanceof Error && activationError.message.includes("No dormant config") ? "MCP server is being reconfigured, please retry" : `MCP server activation failed: ${activationError instanceof Error ? activationError.message : String(activationError)}`;
+              msg.respond(new ErrorResponse({ error: userMessage }));
+              toolCalled = true;
+              continue;
+            }
+          }
           if (!mcpServer) {
             this.logger.warn(`MCP Server ${mcpServerId} not found`);
             continue;
           }
+          if (this.idleTimers.has(mcpServerId)) {
+            this.resetIdleTimer(mcpServerId);
+          }
           let _meta;
           const mcpServerConfig = mcpServer.getConfig();
           if (mcpServerConfig.oauthProvider && userId) {
@@ -153023,7 +153273,7 @@ var ToolService = class ToolService2 extends Service {
               executedBy
             }));
           } catch (callError) {
-            this.logger.error(`Tool call ${tool2.name} failed: ${callError}`);
+            this.logger.error({ mcpServerId, toolName: tool2.name, err: callError }, "Tool call failed");
             msg.respond(new ErrorResponse({
               error: `Tool call failed: ${callError instanceof Error ? callError.message : String(callError)}`
             }));
@@ -153310,6 +153560,11 @@ ${errorOutput}`;
       await this.stopService(service);
     }
     this.mcpServers.delete(mcpServer.id);
+    const idleTimer = this.idleTimers.get(mcpServer.id);
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      this.idleTimers.delete(mcpServer.id);
+    }
     const workspaceId = this.mcpServerWorkspaces.get(mcpServer.id);
     this.publishMCPServerStatus(workspaceId, mcpServer.id, "DISCONNECTED");
     this.mcpServerWorkspaces.delete(mcpServer.id);