reasonix 0.21.0 → 0.22.0

package/dist/index.d.ts

@@ -1637,6 +1637,19 @@ interface SlowEvent {
     p95Ms: number;
     sampleSize: number;
 }
+interface LatencyTrackerOptions {
+    thresholdMs?: number;
+    onSlow?: (ev: SlowEvent) => void;
+}
+declare class LatencyTracker {
+    private readonly serverName;
+    private samples;
+    private wasOverThreshold;
+    private readonly thresholdMs;
+    private readonly onSlow?;
+    constructor(serverName: string, opts?: LatencyTrackerOptions);
+    record(elapsedMs: number): void;
+}
 
 interface BridgeOptions {
     /** Prefix for tool names — disambiguates collisions when bridging multiple servers. */
@@ -1660,6 +1673,12 @@ interface BridgeOptions {
     slowThresholdMs?: number;
     /** Fired exactly when the per-server p95 transitions over `slowThresholdMs`. */
     onSlow?: (ev: SlowEvent) => void;
+    /** Indirection so reconnect can swap the underlying client without re-registering tools. */
+    host?: McpClientHost;
+}
+/** Mutable holder so `/mcp reconnect` can swap the underlying client without re-bridging tools. */
+interface McpClientHost {
+    client: McpClient;
 }
 declare const DEFAULT_MAX_RESULT_CHARS = 32000;
 /** ~6% of DeepSeek V3 context. Char cap alone fails on CJK (~1 char/token). */
@@ -1674,7 +1693,18 @@ interface BridgeResult {
         reason: string;
     }>;
 }
-declare function bridgeMcpTools(client: McpClient, opts?: BridgeOptions): Promise<BridgeResult>;
+/** Resolved bridge environment that `registerSingleMcpTool` needs. Stored on summaries so reconnect can append new tools later. */
+interface BridgeEnv {
+    registry: ToolRegistry;
+    host: McpClientHost;
+    prefix: string;
+    maxResultChars: number;
+    tracker: LatencyTracker | null;
+    onProgress?: BridgeOptions["onProgress"];
+}
+declare function bridgeMcpTools(client: McpClient, opts?: BridgeOptions): Promise<BridgeResult & {
+    env: BridgeEnv;
+}>;
 interface FlattenOptions {
     /** Cap the flattened string at this many characters. Default: no cap. */
     maxChars?: number;

package/dist/index.js

@@ -1065,6 +1065,26 @@ function computeP95(samples) {
 // src/mcp/registry.ts
 var DEFAULT_MAX_RESULT_CHARS = 32e3;
 var DEFAULT_MAX_RESULT_TOKENS = 8e3;
+function registerSingleMcpTool(mcpTool, env) {
+  if (!mcpTool.name) return "";
+  const registeredName = `${env.prefix}${mcpTool.name}`;
+  env.registry.register({
+    name: registeredName,
+    description: mcpTool.description ?? "",
+    parameters: mcpTool.inputSchema,
+    fn: async (args, ctx) => {
+      const t0 = env.tracker ? Date.now() : 0;
+      const live = env.host.client;
+      const toolResult = await live.callTool(mcpTool.name, args, {
+        onProgress: env.onProgress ? (info) => env.onProgress({ toolName: registeredName, ...info }) : void 0,
+        signal: ctx?.signal
+      });
+      if (env.tracker) env.tracker.record(Date.now() - t0);
+      return flattenMcpResult(toolResult, { maxChars: env.maxResultChars });
+    }
+  });
+  return registeredName;
+}
 async function bridgeMcpTools(client, opts = {}) {
   const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
   const prefix = opts.namePrefix ?? "";
@@ -1072,39 +1092,25 @@ async function bridgeMcpTools(client, opts = {}) {
   const result = { registry, registeredNames: [], skipped: [] };
   const serverName = opts.serverName ?? prefix.replace(/_$/, "") ?? "anon";
   const tracker = opts.onSlow ? new LatencyTracker(serverName, { thresholdMs: opts.slowThresholdMs, onSlow: opts.onSlow }) : null;
+  const host = opts.host ?? { client };
+  const env = {
+    registry,
+    host,
+    prefix,
+    maxResultChars,
+    tracker,
+    onProgress: opts.onProgress
+  };
   const listed = await client.listTools();
   for (const mcpTool of listed.tools) {
     if (!mcpTool.name) {
       result.skipped.push({ name: "?", reason: "empty tool name" });
       continue;
     }
-    const registeredName = `${prefix}${mcpTool.name}`;
-    registry.register({
-      name: registeredName,
-      description: mcpTool.description ?? "",
-      parameters: mcpTool.inputSchema,
-      fn: async (args, ctx) => {
-        const t0 = tracker ? Date.now() : 0;
-        const toolResult = await client.callTool(mcpTool.name, args, {
-          // Forward server-side progress frames to the bridge caller,
-          // tagged with the registered name so multi-server UIs can
-          // disambiguate. No-op when `onProgress` isn't configured —
-          // the client then also omits the _meta.progressToken and
-          // the server won't emit progress.
-          onProgress: opts.onProgress ? (info) => opts.onProgress({ toolName: registeredName, ...info }) : void 0,
-          // Thread the tool-dispatch AbortSignal all the way down to
-          // the MCP request so Esc truly cancels in flight — the
-          // client will emit notifications/cancelled AND reject the
-          // pending promise immediately, no "wait for subprocess".
-          signal: ctx?.signal
-        });
-        if (tracker) tracker.record(Date.now() - t0);
-        return flattenMcpResult(toolResult, { maxChars: maxResultChars });
-      }
-    });
-    result.registeredNames.push(registeredName);
+    const registeredName = registerSingleMcpTool(mcpTool, env);
+    if (registeredName) result.registeredNames.push(registeredName);
   }
-  return result;
+  return { ...result, env };
 }
 function flattenMcpResult(result, opts = {}) {
   const parts = result.content.map(blockToString);