reasonix 0.20.0 → 0.22.0

package/dist/index.d.ts

@@ -1631,6 +1631,26 @@ declare class StreamableHttpTransport implements McpTransport {
     private pushMessage;
 }
 
+/** Per-server ring-buffered latency tracker; emits a "slow" event on threshold cross only. */
+interface SlowEvent {
+    serverName: string;
+    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. */
     namePrefix?: string;
@@ -1647,6 +1667,18 @@ interface BridgeOptions {
         total?: number;
         message?: string;
     }) => void;
+    /** Server name used to tag latency samples + slow events. Falls through to namePrefix without trailing `_`. */
+    serverName?: string;
+    /** p95 cutoff in ms before a slow event fires — defaults to 4000. */
+    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). */
@@ -1661,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;
@@ -1807,6 +1850,8 @@ interface ReasonixConfig {
     reasoningEffort?: ReasoningEffort;
     /** Stored as `--mcp`-format strings so one parser handles both flag and config. */
     mcp?: string[];
+    /** Names of servers in `mcp` to skip on bridge — see `/mcp disable <name>`. */
+    mcpDisabled?: string[];
     session?: string | null;
     setupCompleted?: boolean;
     search?: boolean;

package/dist/index.js

@@ -1029,45 +1029,88 @@ function hasDotKey(obj) {
   return false;
 }
 
+// src/mcp/latency.ts
+var SAMPLE_SIZE = 5;
+var DEFAULT_THRESHOLD_MS = 4e3;
+var LatencyTracker = class {
+  constructor(serverName, opts = {}) {
+    this.serverName = serverName;
+    this.thresholdMs = opts.thresholdMs ?? DEFAULT_THRESHOLD_MS;
+    this.onSlow = opts.onSlow;
+  }
+  serverName;
+  samples = [];
+  wasOverThreshold = false;
+  thresholdMs;
+  onSlow;
+  record(elapsedMs) {
+    this.samples.push(elapsedMs);
+    if (this.samples.length > SAMPLE_SIZE) this.samples.shift();
+    if (this.samples.length < SAMPLE_SIZE) return;
+    const p95 = computeP95(this.samples);
+    const nowOver = p95 > this.thresholdMs;
+    if (nowOver && !this.wasOverThreshold) {
+      this.onSlow?.({ serverName: this.serverName, p95Ms: p95, sampleSize: this.samples.length });
+    }
+    this.wasOverThreshold = nowOver;
+  }
+};
+function computeP95(samples) {
+  if (samples.length === 0) return 0;
+  const sorted = [...samples].sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95));
+  return sorted[idx] ?? 0;
+}
+
 // 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 ?? "";
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS;
   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 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
-        });
-        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);