@amodalai/runtime 0.1.15 → 0.1.17

package/dist/src/session/session-manager.js

@@ -4,23 +4,59 @@
  * SPDX-License-Identifier: MIT
  */
 import { randomUUID } from 'node:crypto';
-import { AmodalConfig, Scheduler, ROOT_SCHEDULER_ID, ApprovalMode, PolicyDecision, AgentSDK, buildDefaultPrompt, } from '@amodalai/core';
+import { AmodalConfig, Scheduler, ROOT_SCHEDULER_ID, ApprovalMode, PolicyDecision, AgentSDK, buildDefaultPrompt, resolveScopeLabels, generateFieldGuidance, generateAlternativeLookupGuidance, PlanModeManager, McpManager, ensureAdminAgent, loadAdminAgent, } from '@amodalai/core';
 import { convertSessionMessagesToHistory } from './history-converter.js';
+/**
+ * Resolve env: references in a string record.
+ * "env:VAR_NAME" → process.env.VAR_NAME value
+ */
+function resolveEnvRefs(record) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (value.startsWith('env:')) {
+            const envVar = value.slice(4);
+            resolved[key] = process.env[envVar] ?? '';
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
 const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
 const DEFAULT_CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 const ASK_USER_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Manages per-request sessions: creates Config + GeminiClient + Scheduler
+ * instances, tracks them by ID, and cleans up expired sessions.
+ */
 export class SessionManager {
     sessions = new Map();
     baseParams;
     ttlMs;
     platformApiUrl;
+    repo;
+    toolExecutor;
+    shellExecutor;
+    sharedStoreBackend;
+    sessionStore;
     cleanupTimer = null;
     /** Deduplicates concurrent hydration requests for the same conversation */
     pendingHydrations = new Map();
+    /** Shared MCP manager for all sessions (lazy-initialized, reused) */
+    sharedMcpManager;
+    /** Persistent MCP manager for inspect operations (lazy-initialized) */
+    inspectMcp;
+    inspectMcpInitialized = false;
     constructor(options) {
         this.baseParams = options.baseParams;
         this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
         this.platformApiUrl = options.platformApiUrl;
+        this.repo = options.repo;
+        this.toolExecutor = options.toolExecutor;
+        this.shellExecutor = options.shellExecutor;
+        this.sharedStoreBackend = options.storeBackend;
+        this.sessionStore = options.sessionStore;
         const cleanupIntervalMs = options.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
         this.cleanupTimer = setInterval(() => void this.cleanup(), cleanupIntervalMs);
         // Don't keep the process alive just for cleanup
@@ -39,9 +75,8 @@ export class SessionManager {
             approvalMode: ApprovalMode.YOLO,
             interactive: false,
             noBrowser: true,
-            // Disable all upstream Gemini CLI tools by default.
-            // Only Amodal platform tools (request, present, etc.) are registered.
-            coreTools: [],
+            // Build coreTools list based on repo config
+            coreTools: this.repo ? this.buildCoreToolsList(this.repo) : [],
             policyEngineConfig: {
                 approvalMode: ApprovalMode.YOLO,
                 defaultDecision: PolicyDecision.ALLOW,
@@ -55,6 +90,45 @@ export class SessionManager {
         if (role) {
             sessionParams.activeRole = role;
         }
+        // Inject repo config into session params when in local mode
+        if (this.repo) {
+            const { buildConnectionsMap } = await import('@amodalai/core');
+            const connectionsMap = buildConnectionsMap(this.repo.connections);
+            sessionParams.connections = connectionsMap;
+            sessionParams.appDocuments = this.repo.knowledge.map((k) => ({
+                id: k.name,
+                scope_type: 'application',
+                scope_id: 'local',
+                title: k.title ?? k.name,
+                category: 'system_docs',
+                body: k.body,
+                tags: [],
+                status: 'active',
+                created_by: 'local',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            }));
+            sessionParams.bundleSkills = this.repo.skills.map((s) => ({
+                name: s.name,
+                description: s.description ?? '',
+                body: s.body,
+            }));
+            sessionParams.basePrompt = this.repo.config.basePrompt;
+            sessionParams.agentName = this.repo.config.name;
+            sessionParams.agentContext = this.repo.config.userContext ?? this.repo.config.description;
+            // Model config from repo
+            const mainModel = this.repo.config.models?.main;
+            if (mainModel) {
+                sessionParams.modelConfig = {
+                    provider: mainModel.provider ?? 'anthropic',
+                    model: mainModel.model,
+                };
+            }
+            // Stores
+            if (this.repo.stores.length > 0) {
+                sessionParams.stores = this.repo.stores;
+            }
+        }
         let config;
         // Platform session: use AgentSDK to fetch KB docs, org details, secrets
         if (auth?.token && this.platformApiUrl) {
@@ -87,7 +161,82 @@ export class SessionManager {
                 }
             }
             config = new AmodalConfig(sessionParams);
-            await config.initialize();
+            // For non-platform sessions, skip the full upstream Config.initialize()
+            // which hangs trying to scan files, discover agents, and authenticate
+            // with Gemini. Instead, do a minimal init:
+            // 1. initializeAuth() — sets up MultiProviderContentGenerator for non-Google
+            // 2. registerTools() — registers amodal tools on the upstream registry
+            //
+            // We need to manually create the tool registry and message bus since
+            // the upstream Config only creates them in _initialize().
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            const upstreamRaw = config.getUpstreamConfig();
+            // Initialize storage (required by many upstream components)
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            const storage = (upstreamRaw['storage'] ?? upstreamRaw['_storage']);
+            if (storage?.initialize) {
+                await storage.initialize();
+            }
+            // Create agent registry and tool registry if not already created
+            if (!upstreamRaw['toolRegistry'] && !upstreamRaw['_toolRegistry']) {
+                // Agent registry must exist before tool registry (createToolRegistry references it).
+                // Use a minimal stub — we register Amodal subagents separately.
+                if (!upstreamRaw['agentRegistry']) {
+                    upstreamRaw['agentRegistry'] = {
+                        getAllDefinitions: () => [],
+                        agents: new Map(),
+                        allDefinitions: new Map(),
+                        initialize: async () => { },
+                    };
+                }
+                // Prompt registry stub (referenced by some tools)
+                if (!upstreamRaw['promptRegistry']) {
+                    upstreamRaw['promptRegistry'] = { getPrompts: () => [] };
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                const upstreamConfig = config.getUpstreamConfig();
+                const registry = await upstreamConfig.createToolRegistry();
+                upstreamRaw['_toolRegistry'] = registry;
+            }
+            // Initialize auth (replaces content generator for non-Google providers)
+            await config.initializeAuth();
+            // Register amodal tools (request, present, knowledge, stores)
+            await config.registerTools();
+            // Register custom tools from repo tools/ directory
+            if (this.repo && this.repo.tools.length > 0) {
+                const { CustomToolAdapter } = await import('./custom-tool-adapter.js');
+                const { LocalToolExecutor } = await import('../agent/tool-executor-local.js');
+                const executor = this.toolExecutor ?? new LocalToolExecutor();
+                const registry = config.getUpstreamConfig().getToolRegistry();
+                // Session isn't created yet — we'll set it after session construction
+                // For now store the tools to register after session is built
+                for (const tool of this.repo.tools) {
+                    if (tool.confirm === 'never')
+                        continue; // hidden from LLM
+                    // Create a placeholder session for the adapter — will be updated below
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- partial session for tool context
+                    const placeholder = { config, toolExecutor: executor };
+                    const adapter = new CustomToolAdapter(tool, placeholder, executor);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- adapter matches upstream tool interface
+                    registry.registerTool(adapter);
+                }
+                process.stderr.write(`[SESSION] Registered ${String(this.repo.tools.length)} custom tool(s)\n`);
+            }
+            // Set model on upstream config so GeminiClient.startChat() can resolve it
+            if (sessionParams.modelConfig?.model) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                const upstreamForModel = config.getUpstreamConfig();
+                if (!upstreamForModel.model && !upstreamForModel._model) {
+                    upstreamForModel['model'] = sessionParams.modelConfig.model;
+                    upstreamForModel['_model'] = sessionParams.modelConfig.model;
+                }
+            }
+            // Initialize the GeminiClient (creates the Chat instance)
+            // Must happen after tool registry and content generator are set up.
+            const gemClient = config.getGeminiClient();
+            if (!gemClient.isInitialized()) {
+                await gemClient.initialize();
+            }
         }
         // Inject app secrets as process env vars so shell_exec commands can
         // reference them (e.g. $API_BASE_URL in curl commands). The shell execution
@@ -97,11 +246,6 @@ export class SessionManager {
         const connections = config.getConnections();
         const connKeys = Object.keys(connections).filter((k) => k !== '_secrets');
         process.stderr.write(`[SESSION] connections: ${connKeys.join(', ') || '(none)'}\n`);
-        if (sessionType === 'onboarding' && !connections['platform-api']) {
-            process.stderr.write(`[SESSION] WARNING: onboarding session has no platform-api connection — ` +
-                `the request tool cannot create resources. Check that ADMIN_APP_ID is set ` +
-                `and the seed has run.\n`);
-        }
         // App secrets are available to tools via session-scoped getSessionEnv()
         // (through ToolContext). They are NOT injected into process.env to prevent
         // cross-app secret leakage in multi-session runtimes.
@@ -139,9 +283,10 @@ export class SessionManager {
         // Initialize store backend if stores are configured.
         // Must happen before initializeAuth/tool registration so store tools
         // are available when registerAmodalTools runs.
+        // In local dev mode, use the shared store backend from options.
         const stores = config.getStores();
-        let storeBackend;
-        if (stores.length > 0) {
+        let storeBackend = this.sharedStoreBackend;
+        if (stores.length > 0 && !storeBackend) {
             try {
                 const { PGLiteStoreBackend } = await import('../stores/pglite-store-backend.js');
                 const backend = new PGLiteStoreBackend();
@@ -166,7 +311,36 @@ export class SessionManager {
             name: config.getAgentName() ?? 'Amodal Agent',
             description: config.getAgentDescription(),
             agentContext: config.getAgentContext(),
-            connectionNames: Object.keys(config.getConnections()).filter((k) => k !== '_secrets'),
+            agentOverride: this.repo?.agents?.main,
+            connections: this.repo?.connections ? Array.from(this.repo.connections.values()).map((conn) => ({
+                name: conn.name,
+                endpoints: (conn.surface ?? [])
+                    .filter((ep) => ep.included)
+                    .map((ep) => ({ method: ep.method, path: ep.path, description: ep.description })),
+                entities: conn.entities,
+                rules: conn.rules,
+            })) : undefined,
+            skills: this.repo?.skills?.map((s) => ({
+                name: s.name,
+                description: s.description ?? '',
+                trigger: s.trigger,
+                body: s.body,
+            })),
+            knowledge: this.repo?.knowledge?.map((k) => ({
+                name: k.name,
+                title: k.title,
+                body: k.body,
+            })),
+            ...(this.repo?.connections ? (() => {
+                const { scopeLabels } = resolveScopeLabels(this.repo.connections, []);
+                const fieldGuidance = generateFieldGuidance(this.repo.connections, []);
+                const altLookup = generateAlternativeLookupGuidance(this.repo.connections);
+                return {
+                    fieldGuidance: fieldGuidance || undefined,
+                    scopeLabels: Object.keys(scopeLabels).length > 0 ? scopeLabels : undefined,
+                    alternativeLookupGuidance: altLookup || undefined,
+                };
+            })() : {}),
         });
         try {
             geminiClient.getChat().setSystemInstruction(systemPrompt);
@@ -283,7 +457,79 @@ export class SessionManager {
             model: mc?.model ?? config.getModel(),
             provider: mc?.provider,
             storeBackend,
+            planModeManager: new PlanModeManager(),
+            toolExecutor: this.toolExecutor,
+            shellExecutor: this.shellExecutor,
+            appId: auth?.applicationId,
         };
+        // Share MCP connection across sessions — connect once, reuse for all
+        if (this.repo && !this.sharedMcpManager) {
+            await this.initSharedMcp(this.repo);
+        }
+        if (this.sharedMcpManager) {
+            session.mcpManager = this.sharedMcpManager;
+            // Register MCP tools on the upstream tool registry so the Gemini client can see them
+            try {
+                const upstream = config.getUpstreamConfig();
+                const toolRegistry = upstream.getToolRegistry();
+                const mcpTools = session.mcpManager.getDiscoveredTools();
+                for (const mcpTool of mcpTools) {
+                    // Adapter matching upstream DeclarativeTool interface (build/silentBuild/schema/getSchema)
+                    const mcpSession = session;
+                    const adapter = {
+                        name: mcpTool.name,
+                        displayName: mcpTool.name,
+                        description: mcpTool.description,
+                        kind: 'declarative',
+                        parameterSchema: mcpTool.parameters,
+                        get isReadOnly() { return true; },
+                        get toolAnnotations() { return undefined; },
+                        get schema() { return this.getSchema(); },
+                        getSchema() {
+                            return {
+                                name: mcpTool.name,
+                                description: mcpTool.description,
+                                parametersJsonSchema: mcpTool.parameters,
+                            };
+                        },
+                        build(params) {
+                            return {
+                                name: mcpTool.name,
+                                params,
+                                execute: async () => adapter.validateBuildAndExecute(params),
+                            };
+                        },
+                        silentBuild(params) {
+                            return this.build(params);
+                        },
+                        async validateBuildAndExecute(params) {
+                            try {
+                                const result = await mcpSession.mcpManager.callTool(mcpTool.name, params);
+                                const output = result.content
+                                    .map((c) => c.type === 'text' && c.text ? c.text : `[${c.type}]`)
+                                    .join('\n');
+                                return {
+                                    llmContent: result.isError ? `Error: ${output}` : output,
+                                    returnDisplay: output.slice(0, 200),
+                                    ...(result.isError ? { error: { message: output, type: 'EXECUTION_FAILED' } } : {}),
+                                };
+                            }
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                return { llmContent: `Error: ${msg}`, returnDisplay: msg, error: { message: msg, type: 'EXECUTION_FAILED' } };
+                            }
+                        },
+                    };
+                    toolRegistry.registerTool(adapter); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+                }
+                await geminiClient.setTools();
+                process.stderr.write(`[MCP] Registered ${String(mcpTools.length)} MCP tools on tool registry\n`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`[MCP] Failed to register MCP tools: ${msg}\n`);
+            }
+        }
         this.sessions.set(sessionId, session);
         return session;
     }
@@ -329,31 +575,20 @@ export class SessionManager {
         }
     }
     async doHydrate(conversationId, role, auth, sessionType) {
-        // Fetch stored conversation from platform-api
-        const url = `${this.platformApiUrl}/api/applications/${auth.applicationId}/sessions/${conversationId}`;
+        // Fetch stored conversation via pluggable session store
+        if (!this.sessionStore || !auth?.applicationId || !auth.token) {
+            return null;
+        }
         let record;
         try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), 10_000);
-            const response = await fetch(url, {
-                signal: controller.signal,
-                headers: {
-                    Authorization: `Bearer ${auth.token}`,
-                    Accept: 'application/json',
-                },
-            });
-            clearTimeout(timer);
-            if (!response.ok) {
-                process.stderr.write(`[HYDRATE] Failed to fetch conversation ${conversationId}: HTTP ${response.status}\n`);
-                return null;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- API response shape
-            record = (await response.json());
+            record = await this.sessionStore.getSession(auth.applicationId, conversationId, auth.token);
         }
         catch (err) {
             process.stderr.write(`[HYDRATE] Error fetching conversation ${conversationId}: ${err instanceof Error ? err.message : String(err)}\n`);
             return null;
         }
+        if (!record)
+            return null;
         // No messages → nothing to hydrate
         if (!record.messages || record.messages.length === 0)
             return null;
@@ -395,6 +630,195 @@ export class SessionManager {
         }
         await session.config.shutdownAudit();
     }
+    // ---------------------------------------------------------------------------
+    // Local dev features
+    // ---------------------------------------------------------------------------
+    /**
+     * Get the repo (local dev mode).
+     */
+    getRepo() {
+        return this.repo;
+    }
+    /**
+     * Update the repo for new sessions (hot reload).
+     * Existing sessions keep their old config.
+     */
+    updateRepo(repo) {
+        this.repo = repo;
+        // Reset inspect MCP manager so it picks up new connections
+        this.inspectMcpInitialized = false;
+        this.inspectMcp = undefined;
+    }
+    /**
+     * Re-register a session under a different ID (e.g., restoring original ID on session restore).
+     */
+    reregister(session, newId) {
+        this.sessions.delete(session.id);
+        session.id = newId;
+        this.sessions.set(newId, session);
+    }
+    /**
+     * Create an admin session for the config chat.
+     * Uses admin agent skills/knowledge but the current repo's connections/stores.
+     *
+     * Temporarily swaps repo fields so create() builds the prompt with admin
+     * content, then restores the original repo. This mirrors the old approach
+     * of building an adminRepo overlay.
+     */
+    async createAdminSession(getPort) {
+        if (!this.repo) {
+            throw new Error('Admin sessions require a repo');
+        }
+        if (this.repo.source !== 'local') {
+            throw new Error('Admin sessions are only available for local repos');
+        }
+        const agentDir = await ensureAdminAgent(this.repo.origin);
+        const adminContent = await loadAdminAgent(agentDir);
+        // Save original repo fields
+        const origSkills = this.repo.skills;
+        const origKnowledge = this.repo.knowledge;
+        const origAgents = this.repo.agents;
+        const origAutomations = this.repo.automations;
+        // Swap in admin content so create() builds the prompt correctly
+        this.repo.skills = adminContent.skills;
+        this.repo.knowledge = adminContent.knowledge;
+        this.repo.agents = {
+            main: adminContent.agentPrompt ?? undefined,
+            simple: undefined,
+            subagents: [],
+        };
+        this.repo.automations = [];
+        let session;
+        try {
+            session = await this.create('admin');
+        }
+        finally {
+            // Restore original repo fields
+            this.repo.skills = origSkills;
+            this.repo.knowledge = origKnowledge;
+            this.repo.agents = origAgents;
+            this.repo.automations = origAutomations;
+        }
+        session.appId = 'admin';
+        // Register admin file tools (read/write/delete repo files)
+        try {
+            const { createReadRepoFileTool, createWriteRepoFileTool, createDeleteRepoFileTool } = await import('./admin-file-tools.js');
+            const repoRoot = this.repo.origin;
+            const upstream = session.config.getUpstreamConfig();
+            const toolRegistry = upstream.getToolRegistry();
+            toolRegistry.registerTool(createReadRepoFileTool(repoRoot)); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+            toolRegistry.registerTool(createWriteRepoFileTool(repoRoot)); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+            toolRegistry.registerTool(createDeleteRepoFileTool(repoRoot)); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+            // Internal API tool — lets admin query eval results, health, context, etc.
+            if (getPort) {
+                const { createInternalApiTool } = await import('./admin-file-tools.js');
+                toolRegistry.registerTool(createInternalApiTool(getPort)); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+            }
+            await session.geminiClient.setTools();
+            process.stderr.write('[ADMIN] Registered admin tools (file tools + internal_api)\n');
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[ADMIN] Failed to register file tools: ${msg}\n`);
+        }
+        return session;
+    }
+    /**
+     * Get a persistent MCP manager for inspect/health operations.
+     * Lazy-initialized on first call, reused across requests.
+     */
+    async getInspectMcpManager() {
+        if (this.inspectMcpInitialized)
+            return this.inspectMcp;
+        this.inspectMcpInitialized = true;
+        if (!this.repo)
+            return undefined;
+        // Build MCP server configs from repo connections
+        const mcpServers = this.buildMcpConfigs(this.repo);
+        if (Object.keys(mcpServers).length === 0)
+            return undefined;
+        const manager = new McpManager();
+        try {
+            await manager.startServers(mcpServers);
+            this.inspectMcp = manager;
+            return manager;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[INSPECT] MCP initialization failed: ${msg}\n`);
+            this.inspectMcp = manager;
+            return manager;
+        }
+    }
+    /**
+     * Initialize MCP servers for a session from repo connections.
+     */
+    /**
+     * Initialize the shared MCP manager (once, reused across sessions).
+     * Avoids reconnecting MCP servers for every eval/judge/admin session.
+     */
+    async initSharedMcp(repo) {
+        const mcpServers = this.buildMcpConfigs(repo);
+        if (Object.keys(mcpServers).length === 0)
+            return;
+        const manager = new McpManager();
+        try {
+            await manager.startServers(mcpServers);
+            if (manager.connectedCount > 0) {
+                this.sharedMcpManager = manager;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[SESSION] MCP initialization failed: ${msg}\n`);
+        }
+    }
+    /**
+     * Build the list of upstream core tools to enable based on repo config.
+     * Only tools relevant to the Amodal runtime are included.
+     */
+    buildCoreToolsList(repo) {
+        const tools = [
+            // Always available
+            'enter_plan_mode',
+            'exit_plan_mode',
+            'ask_user',
+        ];
+        // Shell execution (opt-in via config.sandbox.shellExec)
+        if (repo.config.sandbox?.shellExec) {
+            tools.push('shell');
+        }
+        return tools;
+    }
+    /**
+     * Build MCP server configs from repo connections.
+     */
+    buildMcpConfigs(repo) {
+        const mcpServers = {};
+        for (const [name, conn] of repo.connections) {
+            if (conn.spec.protocol === 'mcp') {
+                const resolvedHeaders = conn.spec.headers ? resolveEnvRefs(conn.spec.headers) : undefined;
+                const resolvedEnv = conn.spec.env ? resolveEnvRefs(conn.spec.env) : undefined;
+                mcpServers[name] = {
+                    transport: conn.spec.transport ?? 'stdio',
+                    command: conn.spec.command,
+                    args: conn.spec.args,
+                    env: resolvedEnv,
+                    url: conn.spec.url,
+                    headers: resolvedHeaders,
+                    trust: conn.spec.trust,
+                };
+            }
+        }
+        if (repo.mcpServers) {
+            for (const [name, config] of Object.entries(repo.mcpServers)) {
+                if (!mcpServers[name]) {
+                    mcpServers[name] = config;
+                }
+            }
+        }
+        return mcpServers;
+    }
     /**
      * Remove sessions that have been idle longer than the TTL.
      */
@@ -419,6 +843,18 @@ export class SessionManager {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = null;
         }
+        // Shutdown MCP managers for all sessions
+        for (const session of this.sessions.values()) {
+            if (session.mcpManager) {
+                await session.mcpManager.shutdown().catch(() => { });
+            }
+        }
+        // Shutdown persistent inspect MCP manager
+        if (this.inspectMcp) {
+            await this.inspectMcp.shutdown().catch(() => { });
+            this.inspectMcp = undefined;
+            this.inspectMcpInitialized = false;
+        }
         const ids = [...this.sessions.keys()];
         for (const id of ids) {
             await this.destroy(id);