@wrongstack/mcp 0.309.1 → 0.310.0

package/dist/client.d.ts

@@ -24,34 +24,14 @@ export interface MCPClientOptions {
      */
     passthroughEnv?: string[] | undefined;
 }
-export type ConnectionState = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'failed'
-/** Lazy server: registered from a cached manifest, process not spawned. */
- | 'dormant';
-export interface MCPTool {
-    name: string;
-    description?: string | undefined;
-    inputSchema: Record<string, unknown>;
-}
-export interface ToolCallResult {
-    content: unknown;
-    isError: boolean;
-}
+import type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult } from './contracts.js';
+export type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult };
 export interface MCPRequestOptions {
     signal?: AbortSignal | undefined;
 }
 export interface MCPPageOptions extends MCPRequestOptions {
     cursor?: string | undefined;
 }
-export interface JsonRpcResponse {
-    jsonrpc: '2.0';
-    id: number;
-    result?: unknown | undefined;
-    error?: {
-        code: number | undefined;
-        message: string;
-        data?: unknown | undefined;
-    } | undefined;
-}
 type ExitListener = (name: string, code: number | null, signal: string | null) => void;
 type ToolsChangedListener = (name: string, tools: MCPTool[]) => void;
 export type MCPListChangedListener = (name: string) => void;

package/dist/contracts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Leaf contract types for the @wrongstack/mcp public surface.
+ *
+ * Lives separately from `client.ts` so callers (transport implementations,
+ * schema normalisers, registry helpers) can depend on the wire-level types
+ * without pulling in the MCP client implementation. Breaks the long-standing
+ * type-level SCC ARCH-CYCLE-TYPE-17 where `client.ts` both homed the shared
+ * contracts and was imported back by every transport/schema module.
+ *
+ * This module MUST contain no runtime imports.
+ */
+/** Connection lifecycle states for an MCP client. */
+export type ConnectionState = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'failed'
+/** Lazy server: registered from a cached manifest, process not spawned. */
+ | 'dormant';
+/** Minimal MCP tool descriptor returned by `tools/list`. */
+export interface MCPTool {
+    name: string;
+    description?: string | undefined;
+    inputSchema: Record<string, unknown>;
+}
+/** Result envelope returned by an MCP `tools/call`. */
+export interface ToolCallResult {
+    content: unknown;
+    isError: boolean;
+}
+/** JSON-RPC 2.0 response shape (success or error). */
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number;
+    result?: unknown | undefined;
+    error?: {
+        code: number | undefined;
+        message: string;
+        data?: unknown | undefined;
+    } | undefined;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 export { authorizationHeaderForToken, authorizationServerMetadataUrls, canonicalMcpResource, createMcpAuthorizationRequest, discoverMcpAuthorization, exchangeMcpAuthorizationCode, type MCPAccessToken, type MCPAuthorizationChallenge, type MCPAuthorizationContext, type MCPAuthorizationDiscoveryOptions, type MCPAuthorizationDiscoveryResult, type MCPAuthorizationJsonFetcher, type MCPAuthorizationProvider, type MCPAuthorizationRequestOptions, type MCPAuthorizationServerMetadata, type MCPAuthorizationSession, type MCPProtectedResourceMetadata, type MCPTokenExchangeOptions, type MCPTokenRefreshOptions, type MCPTokenSet, parseAuthorizationServerMetadata, parseMcpAuthorizationCallback, parseMcpBearerChallenge, parseProtectedResourceMetadata, protectedResourceMetadataUrls, refreshMcpAccessToken, validateMcpAuthorizationServerMetadata, } from './authorization.js';
 export { type MCPAuthorizationCompleteInput, MCPAuthorizationManager, type MCPAuthorizationManagerOptions, type MCPAuthorizationStartInput, type MCPAuthorizationStartResult, type MCPAuthorizationStatus, } from './authorization-manager.js';
-export { type ConnectionState, MCPClient, type MCPClientOptions, type MCPListChangedListener, type MCPPageOptions, type MCPRequestOptions, type MCPTool, type ToolCallResult, type Transport, } from './client.js';
+export { MCPClient, type MCPClientOptions, type MCPListChangedListener, type MCPPageOptions, type MCPRequestOptions, type Transport, } from './client.js';
 export { MCP_CONSTANTS } from './constants.js';
 export { DEFAULT_MCP_INSERTION_MAX_BYTES, DEFAULT_MCP_RESOURCE_SCHEMES, type MCPContentProvenance, type MCPInsertionPolicy, type MCPPromptInsertion, type MCPResourceInsertion, preparePromptInsertion, prepareResourceInsertion, } from './content-selection.js';
+export type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult, } from './contracts.js';
 export { addMcp, disableMcp, discoverMcp, enableMcp, listMcp, MCP_ENV_MASK, type McpManageDeps, type McpOpResult, type McpServerInfo, type McpServerInput, removeMcp, restartMcp, updateMcp, } from './manage.js';
 export { type MCPCapabilityManifest, manifestConfigHash, readCapabilityManifest, readManifest, writeCapabilityManifest, writeManifest, } from './manifest-cache.js';
 export { MCP_OPERATION_LIMITS, type MCPFailureKind, type MCPHealthState, type MCPLatencySummary, type MCPOperationEvent, type MCPOperationKind, type MCPServerOperationalHealth, } from './operations.js';

package/dist/index.js

@@ -3471,94 +3471,6 @@ function percentile(sorted, ratio) {
 // src/registry.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
 
-// src/registry-catalog.ts
-var MAX_CATALOG_PAGES = 100;
-var MAX_CATALOG_ITEMS = 1e4;
-async function collectCatalogPages(load, select) {
-  const items = [];
-  const seenCursors = /* @__PURE__ */ new Set();
-  let cursor;
-  for (let pageNumber = 0; pageNumber < MAX_CATALOG_PAGES; pageNumber++) {
-    const page = await load(cursor);
-    items.push(...select(page));
-    if (items.length > MAX_CATALOG_ITEMS) {
-      throw new Error(`MCP catalog exceeds ${MAX_CATALOG_ITEMS} items`);
-    }
-    const next = page.nextCursor;
-    if (!next) return items;
-    if (seenCursors.has(next)) throw new Error(`MCP catalog repeated cursor "${next}"`);
-    seenCursors.add(next);
-    cursor = next;
-  }
-  throw new Error(`MCP catalog exceeds ${MAX_CATALOG_PAGES} pages`);
-}
-function cloneCatalogRecords(records) {
-  return structuredClone(records);
-}
-function registryCatalogSnapshot(slot) {
-  return {
-    name: slot.cfg.name,
-    state: slot.state,
-    serverMetadata: slot.serverMetadata ? structuredClone(slot.serverMetadata) : void 0,
-    resources: slot.resources ? cloneCatalogRecords(slot.resources) : void 0,
-    resourceTemplates: slot.resourceTemplates ? cloneCatalogRecords(slot.resourceTemplates) : void 0,
-    prompts: slot.prompts ? cloneCatalogRecords(slot.prompts) : void 0
-  };
-}
-
-// src/registry-health.ts
-function buildRegistryOperationalHealth(servers, disabledServers) {
-  const active = Array.from(servers).map((slot) => {
-    const op = slot.operations;
-    const baseHealth = healthStateFor(slot.state, op, slot.cfg.enabled !== false);
-    const checks = evaluateHealthThresholds(op, slot.cfg.health?.thresholds);
-    return {
-      name: slot.cfg.name,
-      connectionState: slot.state,
-      healthState: applyHealthThresholds(baseHealth, checks),
-      lastSuccessAt: op.lastSuccessAt,
-      lastFailureAt: op.lastFailureAt,
-      lastFailureKind: op.lastFailureKind,
-      lastReason: op.lastReason,
-      consecutiveFailures: op.consecutiveFailures,
-      failures: { ...op.failures },
-      reconnectCount: op.reconnectCount,
-      wakeCount: op.wakeCount,
-      sleepCount: op.sleepCount,
-      restartCount: op.restartCount,
-      connectionLatency: summarizeLatency(op.connectionSamples),
-      discoveryLatency: summarizeLatency(op.discoverySamples),
-      callLatency: summarizeLatency(op.callSamples),
-      inFlightCalls: op.inFlightCalls,
-      peakInFlightCalls: op.peakInFlightCalls,
-      recentEvents: op.recentEvents.map((event) => ({ ...event })),
-      healthChecks: checks
-    };
-  });
-  const disabled = Array.from(disabledServers).map((cfg) => {
-    const operations = createMCPServerOperationState();
-    return {
-      name: cfg.name,
-      connectionState: "idle",
-      healthState: "disabled",
-      consecutiveFailures: 0,
-      failures: { ...operations.failures },
-      reconnectCount: 0,
-      wakeCount: 0,
-      sleepCount: 0,
-      restartCount: 0,
-      connectionLatency: summarizeLatency([]),
-      discoveryLatency: summarizeLatency([]),
-      callLatency: summarizeLatency([]),
-      inFlightCalls: 0,
-      peakInFlightCalls: 0,
-      recentEvents: [],
-      healthChecks: []
-    };
-  });
-  return [...active, ...disabled];
-}
-
 // src/registry-authorization.ts
 function requireAuthorizationManager(manager) {
   if (!manager) {
@@ -3590,109 +3502,39 @@ async function completeRegistryAuthorization(manager, cfg, name, callbackUrl, si
   });
 }
 
-// src/registry-operations.ts
-function operationsForSlot(slot) {
-  if (!slot.operations) slot.operations = createMCPServerOperationState();
-  return slot.operations;
-}
-function recordRegistrySuccess(slot, resetFailures = true) {
-  const operations = operationsForSlot(slot);
-  operations.lastSuccessAt = Date.now();
-  if (resetFailures) operations.consecutiveFailures = 0;
-}
-function recordRegistryFailure(slot, listeners, failureKind, reason, durationMs) {
-  const operations = operationsForSlot(slot);
-  const safeReason = safeOperationReason(reason);
-  operations.lastFailureAt = Date.now();
-  operations.lastFailureKind = failureKind;
-  operations.lastReason = safeReason;
-  operations.consecutiveFailures++;
-  operations.failures[failureKind]++;
-  recordRegistryOperation(slot, listeners, "failure", safeReason, failureKind, durationMs);
-}
-function recordRegistryOperation(slot, listeners, kind, reason, failureKind, durationMs, retain = true) {
-  const operations = operationsForSlot(slot);
-  const baseHealth = healthStateFor(slot.state, operations, slot.cfg.enabled !== false);
-  const checks = evaluateHealthThresholds(operations, slot.cfg.health?.thresholds);
-  const event = {
-    serverName: slot.cfg.name,
-    kind,
-    at: Date.now(),
-    connectionState: slot.state,
-    healthState: applyHealthThresholds(baseHealth, checks)
-  };
-  if (reason !== void 0) event.reason = safeOperationReason(reason);
-  if (failureKind !== void 0) event.failureKind = failureKind;
-  if (durationMs !== void 0) event.durationMs = Math.max(0, Math.round(durationMs));
-  if (retain) pushBounded(operations.recentEvents, event, MCP_OPERATION_LIMITS.RECENT_EVENTS);
-  for (const listener of listeners) {
-    try {
-      listener({ ...event });
-    } catch {
+// src/registry-catalog.ts
+var MAX_CATALOG_PAGES = 100;
+var MAX_CATALOG_ITEMS = 1e4;
+async function collectCatalogPages(load, select) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (let pageNumber = 0; pageNumber < MAX_CATALOG_PAGES; pageNumber++) {
+    const page = await load(cursor);
+    items.push(...select(page));
+    if (items.length > MAX_CATALOG_ITEMS) {
+      throw new Error(`MCP catalog exceeds ${MAX_CATALOG_ITEMS} items`);
     }
+    const next = page.nextCursor;
+    if (!next) return items;
+    if (seenCursors.has(next)) throw new Error(`MCP catalog repeated cursor "${next}"`);
+    seenCursors.add(next);
+    cursor = next;
   }
+  throw new Error(`MCP catalog exceeds ${MAX_CATALOG_PAGES} pages`);
 }
-
-// src/registry-disconnect.ts
-function resetDisconnectedSlotTools(slot, toolRegistry) {
-  for (const t of slot.toolNames) {
-    try {
-      toolRegistry.unregister(t);
-    } catch {
-    }
-  }
-  slot.toolNames = [];
-  slot.lazyTools = [];
-  slot.serverMetadata = void 0;
-  slot.resources = void 0;
-  slot.resourceTemplates = void 0;
-  slot.prompts = void 0;
+function cloneCatalogRecords(records) {
+  return structuredClone(records);
 }
-function markLazySlotDormant(slot, events, reason) {
-  slot.client = void 0;
-  slot.state = "dormant";
-  events.emit("mcp.server.disconnected", {
+function registryCatalogSnapshot(slot) {
+  return {
     name: slot.cfg.name,
-    reason: `${reason} (dormant)`
-  });
-}
-
-// src/registry-reconnect.ts
-function scheduleRegistryReconnect({
-  slot,
-  events,
-  log,
-  maxReconnectCycles,
-  baseReconnectDelayMs,
-  maxReconnectDelayMs,
-  recordReconnectExhausted,
-  attemptReconnect
-}) {
-  if (slot.reconnectPending) return;
-  if (slot.reconnectCycles >= maxReconnectCycles) {
-    slot.state = "failed";
-    recordReconnectExhausted(slot);
-    log.error(
-      `MCP server "${slot.cfg.name}" giving up after ${slot.reconnectCycles} reconnect cycles. Use \`/mcp restart ${slot.cfg.name}\` to retry.`
-    );
-    events.emit("mcp.server.disconnected", {
-      name: slot.cfg.name,
-      reason: `reconnect-exhausted:${slot.reconnectCycles}`
-    });
-    return;
-  }
-  slot.reconnectPending = true;
-  if (slot.reconnectTimer) {
-    clearTimeout(slot.reconnectTimer);
-    slot.reconnectTimer = void 0;
-  }
-  const base = Math.min(baseReconnectDelayMs * 2 ** slot.reconnectCycles, maxReconnectDelayMs);
-  const jitter = base * MCP_CONSTANTS.RECONNECT.JITTER_FACTOR * (Math.random() * 2 - 1);
-  const delay = Math.max(100, Math.round(base + jitter));
-  slot.reconnectTimer = setTimeout(() => {
-    slot.reconnectTimer = void 0;
-    void attemptReconnect(slot);
-  }, delay);
+    state: slot.state,
+    serverMetadata: slot.serverMetadata ? structuredClone(slot.serverMetadata) : void 0,
+    resources: slot.resources ? cloneCatalogRecords(slot.resources) : void 0,
+    resourceTemplates: slot.resourceTemplates ? cloneCatalogRecords(slot.resourceTemplates) : void 0,
+    prompts: slot.prompts ? cloneCatalogRecords(slot.prompts) : void 0
+  };
 }
 
 // src/registry-connect-loop.ts
@@ -3782,11 +3624,7 @@ function applySlotTools(ctx, slot, tools, client) {
       },
       onFinish: ({ durationMs, ok }) => {
         slot.operations.inFlightCalls = Math.max(0, slot.operations.inFlightCalls - 1);
-        pushBounded(
-          slot.operations.callSamples,
-          durationMs,
-          MCP_OPERATION_LIMITS.LATENCY_SAMPLES
-        );
+        pushBounded(slot.operations.callSamples, durationMs, MCP_OPERATION_LIMITS.LATENCY_SAMPLES);
         if (ok) {
           ctx.recordSuccess(slot);
           ctx.recordOperation(slot, "call", "ok", void 0, durationMs, false);
@@ -3997,6 +3835,83 @@ async function attemptConnectSlot(ctx, slot) {
   }
 }
 
+// src/registry-disconnect.ts
+function resetDisconnectedSlotTools(slot, toolRegistry) {
+  for (const t of slot.toolNames) {
+    try {
+      toolRegistry.unregister(t);
+    } catch {
+    }
+  }
+  slot.toolNames = [];
+  slot.lazyTools = [];
+  slot.serverMetadata = void 0;
+  slot.resources = void 0;
+  slot.resourceTemplates = void 0;
+  slot.prompts = void 0;
+}
+function markLazySlotDormant(slot, events, reason) {
+  slot.client = void 0;
+  slot.state = "dormant";
+  events.emit("mcp.server.disconnected", {
+    name: slot.cfg.name,
+    reason: `${reason} (dormant)`
+  });
+}
+
+// src/registry-health.ts
+function buildRegistryOperationalHealth(servers, disabledServers) {
+  const active = Array.from(servers).map((slot) => {
+    const op = slot.operations;
+    const baseHealth = healthStateFor(slot.state, op, slot.cfg.enabled !== false);
+    const checks = evaluateHealthThresholds(op, slot.cfg.health?.thresholds);
+    return {
+      name: slot.cfg.name,
+      connectionState: slot.state,
+      healthState: applyHealthThresholds(baseHealth, checks),
+      lastSuccessAt: op.lastSuccessAt,
+      lastFailureAt: op.lastFailureAt,
+      lastFailureKind: op.lastFailureKind,
+      lastReason: op.lastReason,
+      consecutiveFailures: op.consecutiveFailures,
+      failures: { ...op.failures },
+      reconnectCount: op.reconnectCount,
+      wakeCount: op.wakeCount,
+      sleepCount: op.sleepCount,
+      restartCount: op.restartCount,
+      connectionLatency: summarizeLatency(op.connectionSamples),
+      discoveryLatency: summarizeLatency(op.discoverySamples),
+      callLatency: summarizeLatency(op.callSamples),
+      inFlightCalls: op.inFlightCalls,
+      peakInFlightCalls: op.peakInFlightCalls,
+      recentEvents: op.recentEvents.map((event) => ({ ...event })),
+      healthChecks: checks
+    };
+  });
+  const disabled = Array.from(disabledServers).map((cfg) => {
+    const operations = createMCPServerOperationState();
+    return {
+      name: cfg.name,
+      connectionState: "idle",
+      healthState: "disabled",
+      consecutiveFailures: 0,
+      failures: { ...operations.failures },
+      reconnectCount: 0,
+      wakeCount: 0,
+      sleepCount: 0,
+      restartCount: 0,
+      connectionLatency: summarizeLatency([]),
+      discoveryLatency: summarizeLatency([]),
+      callLatency: summarizeLatency([]),
+      inFlightCalls: 0,
+      peakInFlightCalls: 0,
+      recentEvents: [],
+      healthChecks: []
+    };
+  });
+  return [...active, ...disabled];
+}
+
 // src/registry-idle.ts
 async function sleepIdleSlot(ctx, slot) {
   slot.reconnectPending = false;
@@ -4032,6 +3947,87 @@ async function sweepIdleSlots(ctx) {
   );
 }
 
+// src/registry-operations.ts
+function operationsForSlot(slot) {
+  if (!slot.operations) slot.operations = createMCPServerOperationState();
+  return slot.operations;
+}
+function recordRegistrySuccess(slot, resetFailures = true) {
+  const operations = operationsForSlot(slot);
+  operations.lastSuccessAt = Date.now();
+  if (resetFailures) operations.consecutiveFailures = 0;
+}
+function recordRegistryFailure(slot, listeners, failureKind, reason, durationMs) {
+  const operations = operationsForSlot(slot);
+  const safeReason = safeOperationReason(reason);
+  operations.lastFailureAt = Date.now();
+  operations.lastFailureKind = failureKind;
+  operations.lastReason = safeReason;
+  operations.consecutiveFailures++;
+  operations.failures[failureKind]++;
+  recordRegistryOperation(slot, listeners, "failure", safeReason, failureKind, durationMs);
+}
+function recordRegistryOperation(slot, listeners, kind, reason, failureKind, durationMs, retain = true) {
+  const operations = operationsForSlot(slot);
+  const baseHealth = healthStateFor(slot.state, operations, slot.cfg.enabled !== false);
+  const checks = evaluateHealthThresholds(operations, slot.cfg.health?.thresholds);
+  const event = {
+    serverName: slot.cfg.name,
+    kind,
+    at: Date.now(),
+    connectionState: slot.state,
+    healthState: applyHealthThresholds(baseHealth, checks)
+  };
+  if (reason !== void 0) event.reason = safeOperationReason(reason);
+  if (failureKind !== void 0) event.failureKind = failureKind;
+  if (durationMs !== void 0) event.durationMs = Math.max(0, Math.round(durationMs));
+  if (retain) pushBounded(operations.recentEvents, event, MCP_OPERATION_LIMITS.RECENT_EVENTS);
+  for (const listener of listeners) {
+    try {
+      listener({ ...event });
+    } catch {
+    }
+  }
+}
+
+// src/registry-reconnect.ts
+function scheduleRegistryReconnect({
+  slot,
+  events,
+  log,
+  maxReconnectCycles,
+  baseReconnectDelayMs,
+  maxReconnectDelayMs,
+  recordReconnectExhausted,
+  attemptReconnect
+}) {
+  if (slot.reconnectPending) return;
+  if (slot.reconnectCycles >= maxReconnectCycles) {
+    slot.state = "failed";
+    recordReconnectExhausted(slot);
+    log.error(
+      `MCP server "${slot.cfg.name}" giving up after ${slot.reconnectCycles} reconnect cycles. Use \`/mcp restart ${slot.cfg.name}\` to retry.`
+    );
+    events.emit("mcp.server.disconnected", {
+      name: slot.cfg.name,
+      reason: `reconnect-exhausted:${slot.reconnectCycles}`
+    });
+    return;
+  }
+  slot.reconnectPending = true;
+  if (slot.reconnectTimer) {
+    clearTimeout(slot.reconnectTimer);
+    slot.reconnectTimer = void 0;
+  }
+  const base = Math.min(baseReconnectDelayMs * 2 ** slot.reconnectCycles, maxReconnectDelayMs);
+  const jitter = base * MCP_CONSTANTS.RECONNECT.JITTER_FACTOR * (Math.random() * 2 - 1);
+  const delay = Math.max(100, Math.round(base + jitter));
+  slot.reconnectTimer = setTimeout(() => {
+    slot.reconnectTimer = void 0;
+    void attemptReconnect(slot);
+  }, delay);
+}
+
 // src/registry.ts
 var MCPRegistry = class _MCPRegistry {
   servers = /* @__PURE__ */ new Map();
@@ -4069,13 +4065,7 @@ var MCPRegistry = class _MCPRegistry {
   }
   async completeAuthorization(name, callbackUrl, signal) {
     const cfg = this.requireHttpServerConfig(name);
-    return completeRegistryAuthorization(
-      this.authorizationManager,
-      cfg,
-      name,
-      callbackUrl,
-      signal
-    );
+    return completeRegistryAuthorization(this.authorizationManager, cfg, name, callbackUrl, signal);
   }
   async authorizationStatus(name) {
     const manager = requireAuthorizationManager(this.authorizationManager);

package/dist/manifest-cache.d.ts

@@ -1,4 +1,4 @@
-import type { MCPTool } from './client.js';
+import type { MCPTool } from './contracts.js';
 import { type MCPPrompt, type MCPResource, type MCPResourceTemplate, type MCPServerMetadata } from './protocol.js';
 export interface MCPCapabilityManifest {
     tools: MCPTool[];

package/dist/operations.d.ts

@@ -1,5 +1,5 @@
 import type { MCPHealthThresholds } from '@wrongstack/core/types';
-import type { ConnectionState } from './client.js';
+import type { ConnectionState } from './contracts.js';
 /** Operator-facing health state. Intentionally separate from transport lifecycle state. */
 export type MCPHealthState = 'disabled' | 'dormant' | 'connecting' | 'healthy' | 'degraded' | 'failed';
 export type MCPFailureKind = 'transport' | 'protocol' | 'tool';

package/dist/registry-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionState } from './client.js';
+import type { ConnectionState } from './contracts.js';
 import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 import type { MCPRegistryCatalog } from './registry-types.js';
 export declare function collectCatalogPages<Page extends {

package/dist/registry-connect-loop.d.ts

@@ -1,7 +1,8 @@
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { Logger } from '@wrongstack/core/types';
-import { MCPClient, type MCPTool } from './client.js';
+import { MCPClient } from './client.js';
+import type { MCPTool } from './contracts.js';
 import { type MCPFailureKind, type MCPOperationKind, type MCPOperationListener } from './operations.js';
 import type { ServerSlot } from './registry-slots.js';
 import type { MCPRegistryOptions } from './registry-types.js';

package/dist/registry-slots.d.ts

@@ -1,7 +1,8 @@
 import type { MCPServerConfig, Tool } from '@wrongstack/core/types';
-import type { ConnectionState, MCPClient } from './client.js';
-import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
+import type { MCPClient } from './client.js';
+import type { ConnectionState } from './contracts.js';
 import type { MCPServerOperationState } from './operations.js';
+import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 export interface ServerSlot {
     cfg: MCPServerConfig;
     client?: MCPClient | undefined;

package/dist/registry-types.d.ts

@@ -3,7 +3,7 @@ import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { Logger, MCPServerConfig } from '@wrongstack/core/types';
 import type { MCPAuthorizationProvider } from './authorization.js';
 import type { MCPAuthorizationManager } from './authorization-manager.js';
-import type { ConnectionState } from './client.js';
+import type { ConnectionState } from './contracts.js';
 import type { MCPPrompt, MCPResource, MCPResourceTemplate, MCPServerMetadata } from './protocol.js';
 export interface MCPRegistryOptions {
     toolRegistry: ToolRegistry;

package/dist/registry.d.ts

@@ -1,10 +1,11 @@
 import type { MCPServerConfig } from '@wrongstack/core/types';
 import type { MCPAuthorizationStartResult, MCPAuthorizationStatus } from './authorization-manager.js';
-import type { ConnectionState, MCPClient } from './client.js';
+import type { MCPClient } from './client.js';
 import { type MCPInsertionPolicy, type MCPPromptInsertion, type MCPResourceInsertion } from './content-selection.js';
+import type { ConnectionState } from './contracts.js';
 import { type MCPOperationListener, type MCPServerOperationalHealth } from './operations.js';
-import type { MCPRegistryCatalog, MCPRegistryOptions } from './registry-types.js';
 import type { MCPGetPromptResult, MCPPrompt, MCPReadResourceResult, MCPResource, MCPResourceTemplate } from './protocol.js';
+import type { MCPRegistryCatalog, MCPRegistryOptions } from './registry-types.js';
 export type { MCPRegistryCatalog, MCPRegistryOptions } from './registry-types.js';
 export declare class MCPRegistry {
     private readonly servers;

package/dist/test-helpers/mock-server.d.ts

@@ -1,4 +1,4 @@
-import type { MCPTool } from '../client.js';
+import type { MCPTool } from '../contracts.js';
 export interface MockToolResponse {
     content: unknown;
     isError?: boolean | undefined;

package/dist/tool-schema.d.ts

@@ -1,3 +1,3 @@
-import type { MCPTool } from './client.js';
+import type { MCPTool } from './contracts.js';
 export declare function normalizeMCPTools(value: unknown): MCPTool[];
 //# sourceMappingURL=tool-schema.d.ts.map

package/dist/transport-base.d.ts

@@ -1,6 +1,6 @@
 import * as https from 'node:https';
 import { type MCPAuthorizationProvider } from './authorization.js';
-import type { ConnectionState, MCPTool } from './client.js';
+import type { ConnectionState, MCPTool } from './contracts.js';
 import type { MCPServerMetadata } from './protocol.js';
 export interface HttpTransportOptions {
     name: string;

package/dist/transport-sse.d.ts

@@ -1,4 +1,4 @@
-import type { JsonRpcResponse, ToolCallResult } from './client.js';
+import type { JsonRpcResponse, ToolCallResult } from './contracts.js';
 import { BaseHTTPTransport, type HttpTransportOptions } from './transport-base.js';
 /**
  * SSE transport for MCP over HTTP.

package/dist/transport-streamable.d.ts

@@ -1,4 +1,4 @@
-import type { JsonRpcResponse, ToolCallResult } from './client.js';
+import type { JsonRpcResponse, ToolCallResult } from './contracts.js';
 import { BaseHTTPTransport, type HttpTransportOptions } from './transport-base.js';
 /**
  * Streamable HTTP transport for MCP.

package/dist/wrap-tool.d.ts

@@ -1,5 +1,6 @@
 import type { Permission, Tool } from '@wrongstack/core/types';
-import type { MCPClient, MCPTool } from './client.js';
+import type { MCPClient } from './client.js';
+import type { MCPTool } from './contracts.js';
 /**
  * Resolves the live client for a tool call. A plain {@link MCPClient} for eager
  * servers, or a thunk that connects-on-demand for lazy/dormant servers (the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "0.309.1",
+  "version": "0.310.0",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,7 +26,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.309.1"
+    "@wrongstack/core": "0.310.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",