salmon-loop 0.2.16 → 0.3.1

package/dist/core/mcp/bridge/tool-bridge.js

@@ -0,0 +1,303 @@
+import { z } from 'zod';
+import { LIMITS } from '../../config/limits.js';
+import { Phase } from '../../types/runtime.js';
+import { classifyMcpTool } from '../policy/classifier.js';
+import { jsonSchemaToZod } from '../schema/json-schema-to-zod.js';
+const MCP_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+const FALLBACK_SIDE_EFFECTS = ['process', 'network'];
+const FALLBACK_ALLOWED_PHASES = [Phase.VERIFY];
+const mcpContentItemSchema = z.object({}).catchall(z.unknown());
+const mcpCallResultSchema = z
+    .object({
+    content: z.array(mcpContentItemSchema).default([]),
+    structuredContent: z.unknown().optional(),
+    isError: z.boolean().optional(),
+    _meta: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+const bridgedMcpToolOutputObjectSchema = z
+    .object({
+    content: z.array(mcpContentItemSchema),
+    structuredContent: z.unknown().optional(),
+    resourceLinks: z.array(mcpContentItemSchema),
+    raw: mcpCallResultSchema,
+    isError: z.boolean().optional(),
+    _meta: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+export const bridgedMcpToolOutputSchema = bridgedMcpToolOutputObjectSchema;
+export function mcpToolDescriptorToToolSpec(input) {
+    assertMcpName(input.serverName, 'server');
+    assertMcpName(input.descriptor.name, 'tool');
+    const classification = normalizeClassifierInput(input.classification);
+    const sideEffects = resolveSideEffects(classification);
+    const riskLevel = input.grant.riskLevel ??
+        classification.riskLevel ??
+        inferRiskLevel(sideEffects, classification.kind);
+    const concurrency = input.grant.concurrency ??
+        classification.concurrency ??
+        inferConcurrency(sideEffects, riskLevel);
+    const allowedPhases = input.grant.allowedPhases.length > 0 ? input.grant.allowedPhases : FALLBACK_ALLOWED_PHASES;
+    const mcpOutputSchema = input.descriptor.outputSchema
+        ? jsonSchemaToZod(input.descriptor.outputSchema).optional()
+        : z.any().optional();
+    return {
+        name: toModelToolName(input.serverName, input.descriptor.name),
+        source: 'mcp',
+        intent: input.grant.intent ?? classification.intent ?? inferIntent(sideEffects),
+        description: input.descriptor.description ?? input.descriptor.title ?? `MCP tool ${input.descriptor.name}`,
+        riskLevel,
+        sideEffects,
+        concurrency,
+        allowedPhases,
+        defaultTimeoutMs: input.grant.defaultTimeoutMs ?? LIMITS.defaultToolTimeoutMs,
+        inputSchema: jsonSchemaToZod(input.descriptor.inputSchema),
+        outputSchema: bridgedMcpToolOutputObjectSchema.extend({
+            structuredContent: mcpOutputSchema,
+        }),
+        summarizeArgsForAuthorization: async (args) => summarizeMcpAuthorization({ ...input, classification }, args, riskLevel, sideEffects),
+        executor: async (rawInput, ctx) => {
+            const args = coerceRecord(rawInput);
+            const result = await input.manager.callTool(input.serverName, input.descriptor.name, args, {
+                signal: ctx.signal,
+            });
+            return wrapMcpToolResult(result);
+        },
+    };
+}
+export function mcpClassifierResultToBridgeClassification(classification) {
+    if ('sideEffects' in classification) {
+        return {
+            kind: 'classified',
+            sideEffects: classification.sideEffects,
+            riskLevel: classification.riskLevel,
+            concurrency: inferConcurrency(classification.sideEffects, classification.riskLevel),
+            intent: inferIntent(classification.sideEffects),
+        };
+    }
+    const sideEffects = sideEffectsFromFacetClassifier(classification.facets);
+    return {
+        kind: 'classified',
+        sideEffects,
+        riskLevel: classification.risk,
+        concurrency: inferConcurrency(sideEffects, classification.risk),
+        intent: inferIntent(sideEffects),
+        reason: classification.reasons.join('; '),
+    };
+}
+export function wrapMcpToolResult(result) {
+    const normalized = unwrapMcpCallResult(result);
+    const content = Array.isArray(normalized.content) ? normalized.content : [];
+    const directResourceLinks = Array.isArray(result.resourceLinks) ? result.resourceLinks : [];
+    const resourceLinks = [...directResourceLinks, ...content.filter(isResourceLink)];
+    const output = {
+        content,
+        resourceLinks,
+        raw: {
+            ...normalized,
+            content,
+        },
+    };
+    if (normalized.structuredContent !== undefined) {
+        output.structuredContent = normalized.structuredContent;
+    }
+    if (normalized.isError !== undefined) {
+        output.isError = normalized.isError;
+    }
+    if (normalized._meta !== undefined) {
+        output._meta = normalized._meta;
+    }
+    return output;
+}
+export function mcpToolToToolSpec(input) {
+    const override = findOverride(input.server.capabilities, input.tool.name);
+    const classification = classifyMcpTool({
+        tool: input.tool,
+        trust: input.server.trust,
+        override,
+    });
+    const phase = input.server.capabilities.tools.phases[0] ?? Phase.VERIFY;
+    const grantDecision = input.policy.decideTool({
+        server: input.server.name,
+        toolName: input.tool.name,
+        phase,
+        classification,
+    });
+    const toolGrant = grantDecision.grant?.kind === 'tool'
+        ? grantDecision.grant
+        : {
+            phases: input.server.capabilities.tools.phases,
+            approval: input.server.capabilities.tools.approval,
+        };
+    const grant = {
+        allowedPhases: toolGrant.phases,
+        riskLevel: classification.riskLevel,
+        metadata: {
+            approval: toolGrant.approval,
+            policy: grantDecision.grant,
+        },
+    };
+    const spec = mcpToolDescriptorToToolSpec({
+        serverName: input.server.name,
+        descriptor: input.tool,
+        grant,
+        classification,
+        manager: input.manager,
+    });
+    return {
+        ...spec,
+        executor: async (args, ctx) => {
+            const runtimePhase = ctx.phase ?? phase;
+            const decision = input.policy.decideTool({
+                server: input.server.name,
+                toolName: input.tool.name,
+                phase: runtimePhase,
+                classification,
+            });
+            if (decision.outcome === 'deny')
+                throw new Error(decision.denyReason ?? 'MCP_TOOL_DENIED');
+            return spec.executor(args, ctx);
+        },
+    };
+}
+export async function registerMcpV2Tools(input) {
+    await input.manager.startAll();
+    for (const server of input.servers) {
+        if (!server.enabled || !server.capabilities.tools.exposeToModel)
+            continue;
+        const catalog = input.manager.getCatalog(server.name);
+        if (!catalog)
+            continue;
+        for (const tool of catalog.tools) {
+            const classification = classifyMcpTool({ tool: tool, trust: server.trust });
+            const decision = input.policy.decideTool({
+                server: server.name,
+                toolName: tool.name,
+                phase: server.capabilities.tools.phases[0] ?? Phase.VERIFY,
+                classification,
+            });
+            if (decision.outcome === 'deny')
+                continue;
+            input.registry.register(mcpToolToToolSpec({
+                server,
+                tool,
+                manager: input.manager,
+                policy: input.policy,
+            }));
+        }
+    }
+}
+function normalizeClassifierInput(classification) {
+    if ('kind' in classification) {
+        return classification;
+    }
+    return mcpClassifierResultToBridgeClassification(classification);
+}
+function sideEffectsFromFacetClassifier(facets) {
+    const effects = [];
+    if (facets.read)
+        effects.push('fs_read');
+    if (facets.write)
+        effects.push('fs_write');
+    if (facets.process)
+        effects.push('process');
+    if (facets.network)
+        effects.push('network');
+    return effects.length > 0 ? effects : ['none'];
+}
+function assertMcpName(value, label) {
+    if (!MCP_NAME_PATTERN.test(value)) {
+        throw new Error(`Invalid MCP ${label} name: ${value}`);
+    }
+}
+function toModelToolName(serverName, toolName) {
+    return `mcp.${serverName}.${toolName}`;
+}
+function findOverride(capabilities, toolName) {
+    return capabilities.tools.sideEffectOverrides?.[toolName];
+}
+function resolveSideEffects(classification) {
+    const effects = classification.kind === 'fallback'
+        ? classification.sideEffects && classification.sideEffects.length > 0
+            ? classification.sideEffects
+            : FALLBACK_SIDE_EFFECTS
+        : classification.sideEffects;
+    return effects.length > 0 ? dedupeSideEffects(effects) : ['none'];
+}
+function dedupeSideEffects(sideEffects) {
+    return Array.from(new Set(sideEffects));
+}
+function inferRiskLevel(sideEffects, classificationKind) {
+    if (classificationKind === 'fallback')
+        return 'high';
+    if (sideEffects.some((effect) => ['fs_write', 'git_write', 'runtime_write', 'snapshot_mutate', 'process', 'network'].includes(effect))) {
+        return 'high';
+    }
+    return 'low';
+}
+function inferConcurrency(sideEffects, riskLevel) {
+    if (riskLevel === 'high')
+        return 'serial_only';
+    if (sideEffects.every((effect) => effect === 'none' || effect === 'fs_read' || effect === 'git_read')) {
+        return 'parallel_ok';
+    }
+    return 'serial_only';
+}
+function inferIntent(sideEffects) {
+    if (sideEffects.includes('fs_write') || sideEffects.includes('git_write'))
+        return 'WRITE';
+    if (sideEffects.includes('fs_read') || sideEffects.includes('git_read'))
+        return 'READ';
+    return 'INFRA';
+}
+function summarizeMcpAuthorization(input, args, riskLevel, sideEffects) {
+    const payload = {
+        server: input.serverName,
+        tool: input.descriptor.name,
+        riskLevel,
+        sideEffects,
+        grant: {
+            allowedPhases: input.grant.allowedPhases,
+            grantedBy: input.grant.grantedBy,
+            grantedAt: input.grant.grantedAt,
+            metadata: input.grant.metadata,
+        },
+        classification: input.classification.kind === 'fallback'
+            ? { kind: 'fallback', reason: input.classification.reason }
+            : { kind: 'classified', reason: input.classification.reason },
+        args,
+    };
+    return safeStringify(payload);
+}
+function safeStringify(value, maxLength = 1200) {
+    try {
+        const raw = JSON.stringify(value);
+        return raw.length <= maxLength ? raw : `${raw.slice(0, maxLength)}...`;
+    }
+    catch {
+        return '[Unserializable]';
+    }
+}
+function coerceRecord(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return {};
+    }
+    return input;
+}
+function unwrapMcpCallResult(result) {
+    if (result.result && typeof result.result === 'object' && !Array.isArray(result.result)) {
+        return {
+            ...result.result,
+            structuredContent: result.structuredContent ?? result.result.structuredContent,
+            resourceLinks: result.resourceLinks,
+        };
+    }
+    return result;
+}
+function isResourceLink(item) {
+    return Boolean(item &&
+        typeof item === 'object' &&
+        item.type === 'resource_link' &&
+        typeof item.uri === 'string');
+}
+//# sourceMappingURL=tool-bridge.js.map

package/dist/core/mcp/cache/resource-cache.js

@@ -0,0 +1,41 @@
+export class ResourceCache {
+    ttlMs;
+    maxEntries;
+    now;
+    entries = new Map();
+    constructor(options = {}) {
+        this.ttlMs = options.ttlMs ?? 30_000;
+        this.maxEntries = options.maxEntries ?? 256;
+        this.now = options.now ?? (() => Date.now());
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt <= this.now()) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlMs = this.ttlMs) {
+        if (this.entries.size >= this.maxEntries) {
+            const firstKey = this.entries.keys().next().value;
+            if (firstKey)
+                this.entries.delete(firstKey);
+        }
+        this.entries.set(key, { value, expiresAt: this.now() + ttlMs });
+    }
+    clear() {
+        this.entries.clear();
+    }
+    deleteMatching(predicate) {
+        for (const key of this.entries.keys()) {
+            if (predicate(key))
+                this.entries.delete(key);
+        }
+    }
+}
+export class McpResourceCache extends ResourceCache {
+}
+//# sourceMappingURL=resource-cache.js.map

package/dist/core/mcp/catalog/discovery.js

@@ -0,0 +1,51 @@
+import { withPromptServer } from './prompt-catalog.js';
+import { withResourceServer, withResourceTemplateServer } from './resource-catalog.js';
+import { withToolServer } from './tool-catalog.js';
+async function safeList(fn, fallback) {
+    try {
+        return await fn();
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function discoverMcpCatalog(params) {
+    const capabilities = params.client.getServerCapabilities();
+    const [toolsResult, resourcesResult, templatesResult, promptsResult] = await Promise.all([
+        capabilities?.tools
+            ? safeList(() => listAllPages((cursor) => params.client.listTools(cursor)), [])
+            : [],
+        capabilities?.resources
+            ? safeList(() => listAllPages((cursor) => params.client.listResources(cursor)), [])
+            : [],
+        capabilities?.resources
+            ? safeList(() => listAllPages((cursor) => params.client.listResourceTemplates(cursor)), [])
+            : [],
+        capabilities?.prompts
+            ? safeList(() => listAllPages((cursor) => params.client.listPrompts(cursor)), [])
+            : [],
+    ]);
+    return {
+        serverName: params.server.name,
+        capabilities,
+        tools: withToolServer(params.server.name, toolsResult),
+        resources: withResourceServer(params.server.name, resourcesResult),
+        resourceTemplates: withResourceTemplateServer(params.server.name, templatesResult),
+        prompts: withPromptServer(params.server.name, promptsResult),
+        refreshedAt: new Date().toISOString(),
+        stale: false,
+    };
+}
+async function listAllPages(fetchPage) {
+    const items = [];
+    let cursor;
+    do {
+        const page = await fetchPage(cursor ? { cursor } : undefined);
+        const values = page.tools ?? page.resources ?? page.resourceTemplates ?? page.prompts;
+        if (Array.isArray(values))
+            items.push(...values);
+        cursor = typeof page.nextCursor === 'string' ? page.nextCursor : undefined;
+    } while (cursor);
+    return items;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/core/mcp/catalog/notification-router.js

@@ -0,0 +1,28 @@
+export class McpNotificationRouter {
+    handlers = [];
+    onInvalidate(handler) {
+        this.handlers.push(handler);
+    }
+    async invalidate(event) {
+        for (const handler of this.handlers) {
+            await handler(event);
+        }
+    }
+    async route(input) {
+        const kind = this.kindForMethod(input.method);
+        if (!kind)
+            return false;
+        await this.invalidate({ serverName: input.serverName, kind });
+        return true;
+    }
+    kindForMethod(method) {
+        if (method === 'notifications/tools/list_changed')
+            return 'tools';
+        if (method === 'notifications/resources/list_changed')
+            return 'resources';
+        if (method === 'notifications/prompts/list_changed')
+            return 'prompts';
+        return null;
+    }
+}
+//# sourceMappingURL=notification-router.js.map

package/dist/core/mcp/catalog/prompt-catalog.js

@@ -0,0 +1,4 @@
+export function withPromptServer(serverName, prompts) {
+    return prompts.map((prompt) => ({ ...prompt, serverName }));
+}
+//# sourceMappingURL=prompt-catalog.js.map

package/dist/core/mcp/catalog/resource-catalog.js

@@ -0,0 +1,7 @@
+export function withResourceServer(serverName, resources) {
+    return resources.map((resource) => ({ ...resource, serverName }));
+}
+export function withResourceTemplateServer(serverName, templates) {
+    return templates.map((template) => ({ ...template, serverName }));
+}
+//# sourceMappingURL=resource-catalog.js.map

package/dist/core/mcp/catalog/tool-catalog.js

@@ -0,0 +1,4 @@
+export function withToolServer(serverName, tools) {
+    return tools.map((tool) => ({ ...tool, serverName }));
+}
+//# sourceMappingURL=tool-catalog.js.map

package/dist/core/mcp/client/connection-manager.js

@@ -0,0 +1,239 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { CallToolResultSchema, PromptListChangedNotificationSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, ResourceUpdatedNotificationSchema, ToolListChangedNotificationSchema, GetPromptResultSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
+import { PACKAGE_VERSION } from '../../version.js';
+import { discoverMcpCatalog } from '../catalog/discovery.js';
+import { McpNotificationRouter } from '../catalog/notification-router.js';
+import { createMcpTransport } from './transport-factory.js';
+function buildClientCapabilities(input) {
+    const capabilities = {
+        roots: input?.roots ? { listChanged: true } : undefined,
+        sampling: input?.sampling ? {} : undefined,
+        elicitation: input?.elicitation ? { form: {} } : undefined,
+    };
+    return capabilities;
+}
+export class McpConnectionManager {
+    servers;
+    clientCapabilities;
+    connections = new Map();
+    resourceUpdateHandlers = [];
+    notifications = new McpNotificationRouter();
+    constructor(servers, clientCapabilities) {
+        this.servers = servers;
+        this.clientCapabilities = clientCapabilities;
+        this.notifications.onInvalidate((event) => {
+            this.markStale(event.serverName, event.kind);
+        });
+    }
+    async startAll() {
+        for (const server of this.servers) {
+            if (!server.enabled)
+                continue;
+            await this.connect(server);
+        }
+    }
+    async connect(server) {
+        const existing = this.connections.get(server.name);
+        if (existing && existing.status === 'ready')
+            return this.view(existing);
+        const transport = createMcpTransport(server);
+        const client = new Client({ name: 'salmon-loop', version: PACKAGE_VERSION }, { capabilities: buildClientCapabilities(this.clientCapabilities) });
+        const entry = {
+            server,
+            client,
+            transport,
+            status: 'connecting',
+            staleKinds: new Set(),
+            subscribedResources: new Set(),
+        };
+        this.connections.set(server.name, entry);
+        client.onerror = (error) => {
+            entry.status = 'degraded';
+            entry.error = error.message;
+            this.markStale(server.name, 'tools');
+            this.markStale(server.name, 'resources');
+            this.markStale(server.name, 'prompts');
+            getLogger().warn(`MCP server ${server.name} degraded: ${error.message}`);
+        };
+        client.onclose = () => {
+            if (entry.status === 'closed')
+                return;
+            entry.status = 'degraded';
+            entry.error = `MCP server ${server.name} connection closed`;
+            this.markStale(server.name, 'tools');
+            this.markStale(server.name, 'resources');
+            this.markStale(server.name, 'prompts');
+        };
+        client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+            await this.notifications.invalidate({ serverName: server.name, kind: 'tools' });
+        });
+        client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
+            await this.notifications.invalidate({ serverName: server.name, kind: 'resources' });
+        });
+        client.setNotificationHandler(ResourceUpdatedNotificationSchema, async (notification) => {
+            const uri = notification.params?.uri;
+            if (typeof uri !== 'string')
+                return;
+            await this.emitResourceUpdated({ serverName: server.name, uri });
+        });
+        client.setNotificationHandler(PromptListChangedNotificationSchema, async () => {
+            await this.notifications.invalidate({ serverName: server.name, kind: 'prompts' });
+        });
+        client.fallbackNotificationHandler = async (notification) => {
+            await this.notifications.route({ serverName: server.name, method: notification.method });
+        };
+        try {
+            await client.connect(transport, { timeout: LIMITS.defaultToolTimeoutMs });
+            entry.catalog = await discoverMcpCatalog({ server, client });
+            entry.status = 'ready';
+            entry.error = undefined;
+            entry.staleKinds.clear();
+        }
+        catch (error) {
+            entry.status = 'degraded';
+            entry.error = error instanceof Error ? error.message : String(error);
+            getLogger().warn(`Failed to connect MCP server ${server.name}: ${entry.error}`);
+        }
+        return this.view(entry);
+    }
+    getCatalog(serverName) {
+        return this.connections.get(serverName)?.catalog;
+    }
+    listCatalogs() {
+        return Array.from(this.connections.values())
+            .map((entry) => entry.catalog)
+            .filter((catalog) => Boolean(catalog));
+    }
+    async refreshCatalog(serverName) {
+        const entry = this.requireReady(serverName);
+        entry.catalog = await discoverMcpCatalog({ server: entry.server, client: entry.client });
+        entry.staleKinds.clear();
+        return entry.catalog;
+    }
+    async callTool(serverName, toolName, args, options) {
+        const entry = this.requireReady(serverName);
+        return entry.client.callTool({ name: toolName, arguments: args }, CallToolResultSchema, {
+            timeout: LIMITS.defaultToolTimeoutMs,
+            signal: options?.signal,
+        });
+    }
+    async readResource(serverName, uri) {
+        const entry = this.requireReady(serverName);
+        return entry.client
+            .readResource({ uri }, { timeout: LIMITS.defaultToolTimeoutMs })
+            .then((result) => {
+            const parsed = ReadResourceResultSchema.parse(result);
+            return this.ensureResourceSubscription(entry, uri).then(() => parsed);
+        });
+    }
+    async getPrompt(serverName, name, args) {
+        const entry = this.requireReady(serverName);
+        return entry.client
+            .getPrompt({ name, arguments: args }, { timeout: LIMITS.defaultToolTimeoutMs })
+            .then((result) => GetPromptResultSchema.parse(result));
+    }
+    async stopAll() {
+        await Promise.all(Array.from(this.connections.values()).map((entry) => this.stopEntry(entry)));
+        this.connections.clear();
+    }
+    async stop(serverName) {
+        const entry = this.connections.get(serverName);
+        if (!entry)
+            return;
+        await this.stopEntry(entry);
+        this.connections.delete(serverName);
+    }
+    views() {
+        return Array.from(this.connections.values()).map((entry) => this.view(entry));
+    }
+    onResourceUpdated(handler) {
+        this.resourceUpdateHandlers.push(handler);
+        return () => {
+            this.resourceUpdateHandlers = this.resourceUpdateHandlers.filter((entry) => entry !== handler);
+        };
+    }
+    markStale(serverName, kind) {
+        const entry = this.connections.get(serverName);
+        if (!entry)
+            return;
+        entry.staleKinds.add(kind);
+        if (kind === 'resources')
+            entry.staleKinds.add('resourceTemplates');
+        if (entry.catalog)
+            entry.catalog = { ...entry.catalog, stale: true };
+    }
+    requireReady(serverName) {
+        const entry = this.connections.get(serverName);
+        if (!entry || entry.status !== 'ready') {
+            throw new Error(`MCP server ${serverName} is not ready`);
+        }
+        return entry;
+    }
+    async ensureResourceSubscription(entry, uri) {
+        if (!entry.server.capabilities.resources.subscribe)
+            return;
+        if (!entry.client.getServerCapabilities()?.resources?.subscribe)
+            return;
+        if (entry.subscribedResources.has(uri))
+            return;
+        try {
+            await entry.client.subscribeResource({ uri }, { timeout: LIMITS.defaultToolTimeoutMs });
+            entry.subscribedResources.add(uri);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            getLogger().warn(`MCP server ${entry.server.name} resource subscription failed for ${uri}: ${message}`);
+        }
+    }
+    async emitResourceUpdated(event) {
+        for (const handler of this.resourceUpdateHandlers) {
+            await handler(event);
+        }
+    }
+    async unsubscribeResources(entry) {
+        if (entry.subscribedResources.size === 0)
+            return;
+        if (!entry.server.capabilities.resources.subscribe) {
+            entry.subscribedResources.clear();
+            return;
+        }
+        if (!entry.client.getServerCapabilities()?.resources?.subscribe) {
+            entry.subscribedResources.clear();
+            return;
+        }
+        for (const uri of entry.subscribedResources) {
+            try {
+                await entry.client.unsubscribeResource({ uri }, { timeout: LIMITS.defaultToolTimeoutMs });
+            }
+            catch {
+                // best-effort unsubscribe during shutdown
+            }
+        }
+        entry.subscribedResources.clear();
+    }
+    async stopEntry(entry) {
+        entry.status = 'closed';
+        try {
+            await this.unsubscribeResources(entry);
+            const maybeHttpTransport = entry.transport;
+            if (typeof maybeHttpTransport.terminateSession === 'function') {
+                await maybeHttpTransport.terminateSession().catch(() => undefined);
+            }
+            await entry.client.close();
+        }
+        catch {
+            // best-effort shutdown
+        }
+    }
+    view(entry) {
+        return {
+            serverName: entry.server.name,
+            status: entry.status,
+            capabilities: entry.client.getServerCapabilities(),
+            error: entry.error,
+        };
+    }
+}
+//# sourceMappingURL=connection-manager.js.map