machine-bridge-mcp 1.2.9 → 1.2.11

package/src/worker/errors.ts

@@ -8,12 +8,14 @@ const WORKER_ERROR_CODES = new Set([
 export class WorkerToolError extends Error {
   readonly code: string;
   readonly retryable: boolean;
+  readonly details?: Record<string, unknown>;
 
-  constructor(code: string, message: string, retryable = false) {
+  constructor(code: string, message: string, retryable = false, details?: Record<string, unknown>) {
     super(message);
     this.name = "WorkerToolError";
     this.code = normalizeCode(code);
     this.retryable = retryable;
+    this.details = details;
   }
 }
 
@@ -23,11 +25,19 @@ export function daemonToolError(value: unknown): WorkerToolError {
   const message = typeof input.message === "string" && input.message
     ? input.message.slice(0, 2000)
     : "daemon tool failed";
-  return new WorkerToolError(code, message, input.retryable === true);
+  return new WorkerToolError(
+    code, message, input.retryable === true,
+    isRecord(input.details) ? input.details : undefined,
+  );
 }
 
-export function publicWorkerToolError(error: unknown): { code: string; message: string; retryable: boolean } {
-  if (error instanceof WorkerToolError) return { code: error.code, message: error.message, retryable: error.retryable };
+export function publicWorkerToolError(error: unknown): { code: string; message: string; retryable: boolean; details?: Record<string, unknown> } {
+  if (error instanceof WorkerToolError) {
+    return {
+      code: error.code, message: error.message, retryable: error.retryable,
+      ...(error.details ? { details: error.details } : {}),
+    };
+  }
   return { code: "execution_failed", message: "tool execution failed", retryable: false };
 }
 
@@ -36,6 +46,10 @@ function normalizeCode(value: unknown): string {
   return WORKER_ERROR_CODES.has(code) ? code : "execution_failed";
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 function asObject(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
 }

package/src/worker/index.ts

@@ -34,13 +34,14 @@ import {
 } from "./websocket-protocol.ts";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "1.2.9";
+const SERVER_VERSION = "1.2.11";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const DEFAULT_MAX_BODY_BYTES = 8 * 1024 * 1024;
 const MAX_BODY_BYTES = 16 * 1024 * 1024;
 const MAX_PENDING_CALLS = 32;
 const MAX_DAEMON_MESSAGE_BYTES = 8 * 1024 * 1024;
+const DAEMON_RECONNECT_GRACE_MS = 30_000;
 
 interface BridgeEnv extends OAuthControllerEnv {
   BRIDGE: DurableObjectNamespace<BridgeRoom>;
@@ -179,11 +180,17 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         return;
       }
       const daemonPolicy = sanitizeDaemonPolicy(body.policy);
+      const instanceId = daemonInstanceId(body.instance_id);
+      if (!instanceId) {
+        rejectDaemonMessage(ws, "invalid_daemon_instance", 1002, "daemon instance id required");
+        return;
+      }
       const authenticatedAt = new Date().toISOString();
       const probeId = randomToken("probe");
       this.daemonRegistry.beginProbe(ws, {
         connectedAt: authenticatedAt,
         probeId,
+        instanceId,
         policy: daemonPolicy,
         tools: sanitizeDaemonTools(body.tools, daemonPolicy),
       });
@@ -218,11 +225,17 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         return;
       }
       const readyAt = new Date().toISOString();
-      if (!this.daemonRegistry.promote(ws, readyAt)) {
+      const readyAttachment = this.daemonRegistry.promote(ws, readyAt);
+      if (!readyAttachment) {
         rejectDaemonMessage(ws, "invalid_relay_readiness_state", 1002, "invalid daemon readiness state");
         return;
       }
+      const reboundCallIds = this.pending.rebindInstance(readyAttachment.instanceId ?? "", ws);
+      if (reboundCallIds.length > 0) {
+        this.observability.event("info", "daemon.calls.rebound", { rebound_calls: reboundCallIds.length });
+      }
       try {
+        ws.send(JSON.stringify({ type: "resume_calls", ids: reboundCallIds }));
         ws.send(JSON.stringify({ type: "ready_ack", server: SERVER_NAME, version: SERVER_VERSION }));
       } catch {
         this.invalidateDaemonSocket(ws, "daemon readiness acknowledgement failed", "daemon ready timeout", "daemon_ready_timeout");
@@ -263,7 +276,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
 
   private async cleanupDaemonSocket(ws: WebSocket, message: string): Promise<void> {
     this.observability.socketDisconnected();
-    this.pending.rejectSocket(ws, () => new WorkerToolError("unavailable", message, true));
+    this.detachDaemonSocketCalls(ws, message);
     await this.scheduleSocketAlarms();
   }
 
@@ -428,6 +441,9 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     this.reclaimStaleDaemonSockets();
     const socket = this.daemonRegistry.readySockets()[0];
     if (!socket) throw new WorkerToolError("unavailable", "local daemon is not connected; keep the CLI start command running", true);
+    const daemonAttachment = this.daemonRegistry.readyAttachment(socket);
+    const daemonInstanceId = daemonAttachment?.instanceId ?? "";
+    if (!daemonInstanceId) throw new WorkerToolError("unavailable", "local daemon connection is missing its instance identity", true);
     const id = randomToken("call");
     const timeoutMs = daemonToolTimeoutMs(name, args);
     let result: Promise<unknown>;
@@ -435,20 +451,23 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
       result = this.pending.register({
         id,
         socket,
+        daemonInstanceId,
         clientRequestKey: requestKey,
         tool: name,
         timeoutMs,
         onTimeout: (record) => {
-          sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
-          const silentForMs = Date.now() - daemonLastSeenMs(this.daemonRegistry.readyAttachment(record.socket));
-          if (!Number.isFinite(silentForMs) || silentForMs > 45_000) {
+          if (record.socket) sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
+          const silentForMs = record.socket
+            ? Date.now() - daemonLastSeenMs(this.daemonRegistry.readyAttachment(record.socket))
+            : 0;
+          if (record.socket && (!Number.isFinite(silentForMs) || silentForMs > 45_000)) {
             this.invalidateDaemonSocket(record.socket, "daemon became unresponsive", "daemon liveness timeout");
           }
           return new WorkerToolError("timeout", `daemon tool timed out: ${name}`, true);
         },
         signal,
         onAbort: (record) => {
-          sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
+          if (record.socket) sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
           return new WorkerToolError("cancelled", "MCP client stopped waiting for the tool result");
         },
       });
@@ -482,7 +501,7 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
   private cancelClientRequest(requestKey?: string): void {
     if (!requestKey) return;
     this.pending.cancelRequest(requestKey, (record) => {
-      sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
+      if (record.socket) sendWebSocketQuietly(record.socket, { type: "cancel_call", id: record.id });
       return new WorkerToolError("cancelled", "tool call cancelled by client");
     });
   }
@@ -542,12 +561,24 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
     closeReason: string,
     errorCode = "daemon_liveness_timeout",
   ): void {
+    this.detachDaemonSocketCalls(ws, message);
     this.daemonRegistry.expire(ws);
-    this.pending.rejectSocket(ws, () => new WorkerToolError("unavailable", message, true));
     sendWebSocketQuietly(ws, { type: "error", error: errorCode });
     closeWebSocketQuietly(ws, 1008, closeReason);
   }
 
+  private detachDaemonSocketCalls(ws: WebSocket, message: string): number {
+    const attachment = this.daemonRegistry.attachment(ws);
+    if (!attachment?.instanceId) {
+      return this.pending.rejectSocket(ws, () => new WorkerToolError("unavailable", message, true));
+    }
+    return this.pending.detachSocket(
+      ws,
+      DAEMON_RECONNECT_GRACE_MS,
+      () => new WorkerToolError("unavailable", `${message}; reconnect grace expired`, true),
+    );
+  }
+
   private reclaimStaleDaemonSockets(now = Date.now()): void {
     for (const socket of this.daemonRegistry.readyRoleSockets()) {
       const deadline = daemonLivenessDeadlineMs(this.daemonRegistry.readyAttachment(socket));
@@ -697,3 +728,8 @@ export default {
     return stub.fetch(request);
   },
 } satisfies ExportedHandler<BridgeEnv>;
+
+function daemonInstanceId(value: unknown): string {
+  if (typeof value !== "string" || !/^daemon_[A-Za-z0-9_-]{16,96}$/.test(value)) return "";
+  return value;
+}

package/src/worker/mcp-jsonrpc.ts

@@ -1,3 +1,4 @@
+import { projectMcpResult } from "../shared/result-projection.mjs";
 const JSONRPC_VERSION = "2.0";
 const MAX_SESSION_INSTRUCTION_BYTES = 3 * 1024 * 1024;
 
@@ -48,11 +49,12 @@ export function textToolResult(value: unknown, isError = false): Record<string,
       return result;
     }
   }
+  const projection = projectMcpResult(value);
   const result: Record<string, unknown> = {
-    content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }],
+    content: [{ type: "text", text: projection.text }],
     isError,
   };
-  if (value && typeof value === "object" && !Array.isArray(value)) result.structuredContent = value;
+  if (projection.structuredContent) result.structuredContent = projection.structuredContent;
   return result;
 }
 

package/src/worker/pending-call-contract.ts

@@ -0,0 +1,26 @@
+export interface PendingCallRecord {
+  id: string;
+  socket?: WebSocket;
+  daemonInstanceId?: string;
+  reconnectTimeout?: ReturnType<typeof setTimeout>;
+  clientRequestKey?: string;
+  tool: string;
+  startedAt: number;
+  timeout: ReturnType<typeof setTimeout>;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  signal?: AbortSignal;
+  abortHandler?: () => void;
+}
+
+export interface RegisterPendingCall {
+  id: string;
+  socket: WebSocket;
+  daemonInstanceId?: string;
+  clientRequestKey?: string;
+  tool: string;
+  timeoutMs: number;
+  onTimeout: (record: PendingCallRecord) => Error;
+  signal?: AbortSignal;
+  onAbort?: (record: PendingCallRecord) => Error;
+}

package/src/worker/pending-calls.ts

@@ -1,3 +1,5 @@
+import type { PendingCallRecord, RegisterPendingCall } from "./pending-call-contract.ts";
+
 export class PendingCallRegistrationError extends Error {
   readonly code: "conflict" | "limit_exceeded";
   readonly retryable: boolean;
@@ -10,30 +12,6 @@ export class PendingCallRegistrationError extends Error {
   }
 }
 
-export interface PendingCallRecord {
-  id: string;
-  socket: WebSocket;
-  clientRequestKey?: string;
-  tool: string;
-  startedAt: number;
-  timeout: ReturnType<typeof setTimeout>;
-  resolve: (value: unknown) => void;
-  reject: (error: Error) => void;
-  signal?: AbortSignal;
-  abortHandler?: () => void;
-}
-
-interface RegisterPendingCall {
-  id: string;
-  socket: WebSocket;
-  clientRequestKey?: string;
-  tool: string;
-  timeoutMs: number;
-  onTimeout: (record: PendingCallRecord) => Error;
-  signal?: AbortSignal;
-  onAbort?: (record: PendingCallRecord) => Error;
-}
-
 export class PendingCallRegistry {
   private readonly maximum: number;
   private readonly byId = new Map<string, PendingCallRecord>();
@@ -78,6 +56,7 @@ export class PendingCallRegistry {
       const record: PendingCallRecord = {
         id: input.id,
         socket: input.socket,
+        daemonInstanceId: input.daemonInstanceId,
         clientRequestKey: input.clientRequestKey,
         tool: String(input.tool || "unknown"),
         startedAt,
@@ -126,16 +105,52 @@ export class PendingCallRegistry {
     return ids.length;
   }
 
-  snapshot(): { active: number; request_keys: number; maximum: number; oldest_ms: number; by_tool: Record<string, number> } {
+  detachSocket(
+    socket: WebSocket,
+    graceMs: number,
+    createError: (record: PendingCallRecord) => Error,
+  ): number {
+    const records = [...this.byId.values()].filter((record) => record.socket === socket);
+    const delay = Math.max(1, Math.floor(Number(graceMs) || 1));
+    for (const record of records) {
+      record.socket = undefined;
+      if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
+      record.reconnectTimeout = setTimeout(() => {
+        const current = this.byId.get(record.id);
+        if (!current || current.socket) return;
+        const expired = this.take(record.id);
+        if (expired) expired.reject(createError(expired));
+      }, delay);
+    }
+    return records.length;
+  }
+
+  rebindInstance(daemonInstanceId: string, socket: WebSocket): string[] {
+    if (!daemonInstanceId) return [];
+    const rebound: string[] = [];
+    for (const record of this.byId.values()) {
+      if (record.socket || record.daemonInstanceId !== daemonInstanceId) continue;
+      if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
+      record.reconnectTimeout = undefined;
+      record.socket = socket;
+      rebound.push(record.id);
+    }
+    return rebound;
+  }
+
+  snapshot(): { active: number; detached: number; request_keys: number; maximum: number; oldest_ms: number; by_tool: Record<string, number> } {
     const now = performance.now();
     const byTool: Record<string, number> = {};
+    let detached = 0;
     let oldestMs = 0;
     for (const record of this.byId.values()) {
       byTool[record.tool] = (byTool[record.tool] || 0) + 1;
+      if (!record.socket) detached += 1;
       oldestMs = Math.max(oldestMs, now - record.startedAt);
     }
     return {
       active: this.byId.size,
+      detached,
       request_keys: this.byRequestKey.size,
       maximum: this.maximum,
       oldest_ms: oldestMs,
@@ -147,6 +162,7 @@ export class PendingCallRegistry {
     const record = this.byId.get(id);
     if (!record) return undefined;
     clearTimeout(record.timeout);
+    if (record.reconnectTimeout) clearTimeout(record.reconnectTimeout);
     if (record.signal && record.abortHandler) record.signal.removeEventListener("abort", record.abortHandler);
     this.byId.delete(id);
     if (record.clientRequestKey && this.byRequestKey.get(record.clientRequestKey) === id) {

package/tsconfig.local.json

@@ -24,6 +24,7 @@
     "src/local/call-registry.mjs",
     "src/local/policy.mjs",
     "src/local/runtime-paths.mjs",
+    "src/local/relay-call-recovery.mjs",
     "src/local/agent-context-projection.mjs",
     "src/local/agent-skill-discovery.mjs",
     "src/local/agent-text-file.mjs",