machine-bridge-mcp 3.0.0-beta.20 → 3.0.0-beta.21

package/src/worker/mcp-stream-dispatch.ts

@@ -1,10 +1,13 @@
-import type { PendingCallOutcome, PendingCallRecord } from "./pending-call-contract.ts";
-import { PendingCallRegistrationError, PendingCallRegistry } from "./pending-calls.ts";
-import type { DaemonSocketRegistry } from "./daemon-sockets.ts";
+import type { PendingCallOutcome } from "./pending-call-contract.ts";
+import type { JsonRpcMessage, McpResumptionStore } from "./mcp-resumption.ts";
+import {
+  McpPendingCallConflictError,
+  McpPendingCallLimitError,
+} from "./mcp-pending-call-store.ts";
+import type { PendingStreamTransform } from "./mcp-pending-call-records.ts";
 import { publicWorkerToolError, WorkerToolError } from "./errors.ts";
 import { workerErrorClass } from "./http.ts";
 import { rpcResult, textToolResult } from "./mcp-jsonrpc.ts";
-import type { JsonRpcMessage, McpResumptionStore } from "./mcp-resumption.ts";
 import { randomToken } from "./oauth-state.ts";
 import type { WorkerObservability } from "./observability.ts";
 
@@ -17,7 +20,6 @@ export type StreamCallAuthorization = {
 };
 
 type StartStreamCallInput = {
-  pending: PendingCallRegistry;
   resumption: McpResumptionStore;
   observability: WorkerObservability;
   streamId: string;
@@ -27,11 +29,13 @@ type StartStreamCallInput = {
   arguments: Record<string, unknown>;
   socket: WebSocket;
   daemonInstanceId: string;
+  connectionId: string;
   timeoutMs: number;
   authorization: StreamCallAuthorization;
-  onTimeout: (record: PendingCallRecord) => Error;
+  transientActiveCount: number;
+  maximumPendingCalls: number;
+  transform?: PendingStreamTransform;
   onSendFailure: () => void | Promise<void>;
-  transformResult?: (value: unknown) => unknown;
 };
 
 type ImmediateOutcomeInput = {
@@ -50,9 +54,10 @@ export function buildServerInfoResult(input: {
   oauth: Record<string, unknown>;
   authorization: Record<string, any>;
   daemon: Record<string, any>;
-  tools: string[];
-  pending: PendingCallRegistry;
-  daemonRegistry: DaemonSocketRegistry;
+  effectiveTools: string[];
+  advertisedTools: string[];
+  pendingSnapshot: Record<string, unknown>;
+  daemonRegistry: import("./daemon-sockets.ts").DaemonSocketRegistry;
   observability: WorkerObservability;
 }): Record<string, unknown> {
   const probing = input.daemonRegistry.probingSockets().length;
@@ -68,7 +73,7 @@ export function buildServerInfoResult(input: {
     authority_summary: input.authorization.summary,
     daemon: input.daemon,
     worker: {
-      pending_calls: input.pending.snapshot(),
+      pending_calls: input.pendingSnapshot,
       daemon_candidates: candidates,
       daemon_probes: probing,
       sockets_live: {
@@ -79,14 +84,15 @@ export function buildServerInfoResult(input: {
       },
       observability: input.observability.snapshot(),
     },
-    tools: input.tools,
+    tools: input.effectiveTools,
     tools_scope: "authenticated_account_effective_tools_before_host_filtering",
     tool_delivery: {
       full_profile_scope: "daemon-capability-ceiling-before-account-filtering",
       daemon_advertised_tool_count: input.daemon.tool_count,
-      relay_advertised_tool_count: input.tools.length,
-      effective_account_tool_count: input.tools.length,
-      relay_advertised_scope: "authenticated_account_effective_tools_before_host_filtering",
+      relay_advertised_tool_count: input.advertisedTools.length,
+      effective_account_tool_count: input.effectiveTools.length,
+      relay_advertised_scope: "stable_authenticated_account_catalog_before_host_filtering",
+      effective_scope: "live_daemon_and_account_intersection_before_host_filtering",
       host_exposed_tools_known_to_server: false,
       host_may_expose_subset: true,
     },
@@ -95,30 +101,28 @@ export function buildServerInfoResult(input: {
 
 export async function startEventDrivenStreamCall(input: StartStreamCallInput): Promise<void> {
   const callId = randomToken("call");
-  const settle = createStreamSettlement({
-    resumption: input.resumption,
-    observability: input.observability,
-    streamId: input.streamId,
-    requestId: input.requestId,
-    tool: input.tool,
-    transformResult: input.transformResult,
-  });
   try {
-    input.pending.registerEvent({
-      id: callId,
-      socket: input.socket,
+    await input.resumption.calls.activate({
+      streamId: input.streamId,
+      callId,
       daemonInstanceId: input.daemonInstanceId,
+      connectionId: input.connectionId,
       clientRequestKey: input.clientRequestKey,
       tool: input.tool,
       timeoutMs: input.timeoutMs,
-      onTimeout: input.onTimeout,
-      settle,
+      transform: input.transform,
+      transientActiveCount: input.transientActiveCount,
+      maximumPendingCalls: input.maximumPendingCalls,
     });
   } catch (error) {
-    if (error instanceof PendingCallRegistrationError) throw new WorkerToolError(error.code, error.message, error.retryable);
+    if (error instanceof McpPendingCallLimitError) {
+      throw new WorkerToolError("limit_exceeded", error.message, true);
+    }
+    if (error instanceof McpPendingCallConflictError) {
+      throw new WorkerToolError("conflict", error.message);
+    }
     throw error;
   }
-  input.resumption.activate(input.streamId);
   input.observability.callStarted(input.tool);
   try {
     input.socket.send(JSON.stringify({
@@ -130,7 +134,9 @@ export async function startEventDrivenStreamCall(input: StartStreamCallInput): P
       authorization: input.authorization,
     }));
   } catch {
-    await input.pending.reject(callId, new WorkerToolError("network_error", "failed to send daemon tool call", true), input.socket);
+    const error = new WorkerToolError("network_error", "failed to send daemon tool call", true);
+    await input.resumption.calls.complete(callId, input.connectionId, streamTerminalMessage(input.requestId, { ok: false, error }));
+    input.observability.callFinished(input.tool, error.code);
     await input.onSendFailure();
   }
 }
@@ -144,28 +150,7 @@ export async function persistImmediateStreamOutcome(input: ImmediateOutcomeInput
   }
 }
 
-function createStreamSettlement(input: {
-  resumption: McpResumptionStore;
-  observability: WorkerObservability;
-  streamId: string;
-  requestId: string | number;
-  tool: string;
-  transformResult?: (value: unknown) => unknown;
-}): (outcome: PendingCallOutcome) => Promise<void> {
-  return async (outcome) => {
-    const normalized = normalizeOutcome(outcome, input.transformResult);
-    const code = normalized.ok ? "" : publicWorkerToolError(normalized.error).code;
-    const message = streamTerminalMessage(input.requestId, normalized);
-    try {
-      await input.resumption.complete(input.streamId, message);
-    } catch (error) {
-      input.observability.event("error", "mcp.stream.persist.failed", { error_class: workerErrorClass(error) });
-    }
-    input.observability.callFinished(input.tool, code);
-  };
-}
-
-function streamTerminalMessage(
+export function streamTerminalMessage(
   requestId: string | number,
   outcome: PendingCallOutcome,
   transformResult?: (value: unknown) => unknown,
@@ -179,7 +164,10 @@ function streamTerminalMessage(
   return message;
 }
 
-function normalizeOutcome(outcome: PendingCallOutcome, transformResult?: (value: unknown) => unknown): PendingCallOutcome {
+export function normalizeOutcome(
+  outcome: PendingCallOutcome,
+  transformResult?: (value: unknown) => unknown,
+): PendingCallOutcome {
   if (!outcome.ok || !transformResult) return outcome;
   try { return { ok: true, value: transformResult(outcome.value) }; }
   catch (error) { return { ok: false, error: error instanceof Error ? error : new Error("stream result transformation failed") }; }

package/src/worker/pending-admission.ts

@@ -0,0 +1,15 @@
+export class PendingAdmissionGate {
+  private tail: Promise<void> = Promise.resolve();
+
+  async run<T>(operation: () => T | Promise<T>): Promise<T> {
+    let release: () => void = () => {};
+    const predecessor = this.tail;
+    this.tail = new Promise<void>((resolve) => { release = resolve; });
+    await predecessor;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+}

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

@@ -2,9 +2,10 @@ export type PendingCallOutcome =
   | { ok: true; value: unknown }
   | { ok: false; error: Error };
 
-export type PendingCallSettlement =
-  | { kind: "promise"; resolve: (value: unknown) => void; reject: (error: Error) => void }
-  | { kind: "event"; settle: (outcome: PendingCallOutcome) => void | Promise<void> };
+export type PendingCallSettlement = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+};
 
 export interface PendingCallRecord {
   id: string;
@@ -36,7 +37,3 @@ export interface RegisterPendingCall {
   signal?: AbortSignal;
   onAbort?: (record: PendingCallRecord) => Error;
 }
-
-export interface RegisterEventPendingCall extends RegisterPendingCall {
-  settle: (outcome: PendingCallOutcome) => void | Promise<void>;
-}

package/src/worker/pending-calls.ts

@@ -1,4 +1,4 @@
-import type { PendingCallOutcome, PendingCallRecord, PendingCallSettlement, RegisterEventPendingCall, RegisterPendingCall } from "./pending-call-contract.ts";
+import type { PendingCallOutcome, PendingCallRecord, PendingCallSettlement, RegisterPendingCall } from "./pending-call-contract.ts";
 import { PendingCallDeadlines, type PendingCallDeadlineOptions } from "./pending-call-deadlines.ts";
 
 export class PendingCallRegistrationError extends Error {
@@ -41,15 +41,10 @@ export class PendingCallRegistry {
     let resolveResult!: (value: unknown) => void;
     let rejectResult!: (error: Error) => void;
     const result = new Promise<unknown>((resolve, reject) => { resolveResult = resolve; rejectResult = reject; });
-    this.add(input, { kind: "promise", resolve: resolveResult, reject: rejectResult });
+    this.add(input, { resolve: resolveResult, reject: rejectResult });
     return result;
   }
 
-  registerEvent(input: RegisterEventPendingCall): void {
-    this.assertCanRegister(input);
-    this.add(input, { kind: "event", settle: input.settle });
-  }
-
   resolve(id: string, socket: WebSocket, value: unknown): Promise<boolean> {
     const record = this.byId.get(id);
     return !record || record.socket !== socket ? Promise.resolve(false) : this.finish(id, { ok: true, value });
@@ -101,7 +96,7 @@ export class PendingCallRegistry {
 
   snapshot(): { active: number; detached: number; request_keys: number; maximum: number; oldest_ms: number; by_tool: Record<string, number> } {
     const now = this.deadlines.now();
-    const byTool: Record<string, number> = {};
+    const byTool = Object.create(null) as Record<string, number>;
     let detached = 0;
     let oldestMs = 0;
     for (const record of this.byId.values()) {
@@ -161,8 +156,7 @@ export class PendingCallRegistry {
   private async finish(id: string, outcome: PendingCallOutcome): Promise<boolean> {
     const record = this.take(id);
     if (!record) return false;
-    if (record.settlement.kind === "promise") outcome.ok ? record.settlement.resolve(outcome.value) : record.settlement.reject(outcome.error);
-    else await record.settlement.settle(outcome);
+    outcome.ok ? record.settlement.resolve(outcome.value) : record.settlement.reject(outcome.error);
     return true;
   }
 

package/src/worker/runtime-alarm-storage.ts

@@ -0,0 +1,35 @@
+export interface AlarmStorage {
+  getAlarm(): Promise<number | null>;
+  setAlarm(scheduledTime: number | Date): Promise<void>;
+  deleteAlarm(): Promise<void>;
+}
+
+export async function writeEarliestRuntimeAlarm(input: {
+  storage: AlarmStorage;
+  nextDeadline: number;
+  now: number;
+  onError: (error: unknown) => void;
+  onMutation?: (action: "set" | "delete" | "noop") => void;
+}): Promise<void> {
+  try {
+    const current = await input.storage.getAlarm();
+    if (!Number.isFinite(input.nextDeadline)) {
+      if (current === null) {
+        input.onMutation?.("noop");
+        return;
+      }
+      await input.storage.deleteAlarm();
+      input.onMutation?.("delete");
+      return;
+    }
+    const target = Math.max(input.now, input.nextDeadline);
+    if (current !== null && current > input.now && current <= target) {
+      input.onMutation?.("noop");
+      return;
+    }
+    await input.storage.setAlarm(target);
+    input.onMutation?.("set");
+  } catch (error) {
+    input.onError(error);
+  }
+}

package/src/worker/runtime-alarm.ts

@@ -4,14 +4,10 @@ import {
   daemonReadyDeadlineMs,
 } from "./daemon-liveness.ts";
 import type { DaemonSocketRegistry } from "./daemon-sockets.ts";
+import type { McpPendingCallStore, PendingStreamCallView } from "./mcp-pending-call-store.ts";
 import type { PendingCallRegistry } from "./pending-calls.ts";
 import { closeWebSocketQuietly, sendWebSocketQuietly } from "./websocket-protocol.ts";
-
-interface AlarmStorage {
-  getAlarm(): Promise<number | null>;
-  setAlarm(scheduledTime: number | Date): Promise<void>;
-  deleteAlarm(): Promise<void>;
-}
+import { writeEarliestRuntimeAlarm, type AlarmStorage } from "./runtime-alarm-storage.ts";
 
 type InvalidateDaemonSocket = (
   socket: WebSocket,
@@ -23,6 +19,8 @@ type InvalidateDaemonSocket = (
 interface RuntimeAlarmContext {
   storage: AlarmStorage;
   pending: PendingCallRegistry;
+  durableCalls?: Pick<McpPendingCallStore, "due" | "nextDeadlineDelayMs">;
+  expireDurableCall?: (call: PendingStreamCallView) => Promise<void>;
   daemonRegistry: DaemonSocketRegistry;
   invalidateDaemonSocket: InvalidateDaemonSocket;
   onScheduleError: (error: unknown) => void;
@@ -31,7 +29,10 @@ interface RuntimeAlarmContext {
 
 export async function processRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
   await context.pending.expireDue();
-  let nextDeadline = pendingAlarmDeadline(context.pending, now);
+  if (context.durableCalls && context.expireDurableCall) {
+    for (const call of await context.durableCalls.due(now)) await context.expireDurableCall(call);
+  }
+  let nextDeadline = await pendingAlarmDeadline(context, now);
   for (const socket of context.daemonRegistry.candidateSockets()) {
     const attachment = context.daemonRegistry.attachment(socket);
     const connectedAt = Date.parse(attachment?.connectedAt ?? "");
@@ -67,11 +68,17 @@ export async function processRuntimeAlarm(context: RuntimeAlarmContext, now = Da
     }
     nextDeadline = Math.min(nextDeadline, deadline);
   }
-  await writeRuntimeAlarm(context, nextDeadline, now);
+  await writeEarliestRuntimeAlarm({
+    storage: context.storage,
+    nextDeadline,
+    now,
+    onError: context.onScheduleError,
+    onMutation: context.onAlarmMutation,
+  });
 }
 
 export async function scheduleRuntimeAlarm(context: RuntimeAlarmContext, now = Date.now()): Promise<void> {
-  let nextDeadline = pendingAlarmDeadline(context.pending, now);
+  let nextDeadline = await pendingAlarmDeadline(context, now);
   for (const socket of context.daemonRegistry.candidateSockets()) {
     const connectedAt = Date.parse(context.daemonRegistry.attachment(socket)?.connectedAt ?? "");
     if (!Number.isFinite(connectedAt)) {
@@ -103,37 +110,20 @@ export async function scheduleRuntimeAlarm(context: RuntimeAlarmContext, now = D
     }
     nextDeadline = Math.min(nextDeadline, deadline);
   }
-  await writeRuntimeAlarm(context, nextDeadline, now);
+  await writeEarliestRuntimeAlarm({
+    storage: context.storage,
+    nextDeadline,
+    now,
+    onError: context.onScheduleError,
+    onMutation: context.onAlarmMutation,
+  });
 }
 
-function pendingAlarmDeadline(pending: PendingCallRegistry, now: number): number {
-  const delay = pending.nextDeadlineDelayMs();
+async function pendingAlarmDeadline(context: RuntimeAlarmContext, now: number): Promise<number> {
+  const transientDelay = context.pending.nextDeadlineDelayMs();
+  const durableDelay = context.durableCalls
+    ? await context.durableCalls.nextDeadlineDelayMs()
+    : Number.POSITIVE_INFINITY;
+  const delay = Math.min(transientDelay, durableDelay);
   return Number.isFinite(delay) ? now + Math.max(1, Math.ceil(delay)) : Number.POSITIVE_INFINITY;
 }
-
-async function writeRuntimeAlarm(context: RuntimeAlarmContext, nextDeadline: number, now: number): Promise<void> {
-  try {
-    const current = await context.storage.getAlarm();
-    if (!Number.isFinite(nextDeadline)) {
-      if (current === null) {
-        context.onAlarmMutation?.("noop");
-        return;
-      }
-      await context.storage.deleteAlarm();
-      context.onAlarmMutation?.("delete");
-      return;
-    }
-
-    const target = Math.max(now, nextDeadline);
-    // An earlier future alarm is safe: it will re-evaluate current liveness and
-    // pending deadlines. Do not rewrite it on every heartbeat merely to move it later.
-    if (current !== null && current > now && current <= target) {
-      context.onAlarmMutation?.("noop");
-      return;
-    }
-    await context.storage.setAlarm(target);
-    context.onAlarmMutation?.("set");
-  } catch (error) {
-    context.onScheduleError(error);
-  }
-}

package/src/worker/websocket-protocol.ts

@@ -21,6 +21,10 @@ export function sendWebSocketQuietly(ws: WebSocket, value: unknown): void {
   trySendWebSocket(ws, value);
 }
 
+export function daemonErrorCloseCode(errorCode: string): number {
+  return errorCode === "daemon_transport_error" || errorCode === "daemon_liveness_timeout" ? 1012 : 1008;
+}
+
 export function closeWebSocketQuietly(ws: WebSocket, code?: number, reason?: string): void {
   try {
     ws.close(code, reason);

package/src/worker/worker-entry.ts

@@ -0,0 +1,50 @@
+import {
+  proxyMcpEventStream,
+  sanitizeBridgeRequest,
+} from "./mcp-stream-proxy.ts";
+import { respondWithoutDurableObject } from "./worker-static-routes.ts";
+import { createThrottledEdgeLogger } from "./worker-edge-log.ts";
+import {
+  admitStatefulRequest,
+  durableObjectQuotaResponse,
+  isDurableObjectQuotaError,
+  outerWorkerErrorClass,
+  workerGatewayErrorResponse,
+} from "./worker-edge-guard.ts";
+
+type OuterBridgeStub = { fetch(request: Request): Promise<Response> };
+type OuterBridgeNamespace = { getByName(name: string): OuterBridgeStub };
+
+export interface OuterWorkerEnv {
+  BRIDGE: OuterBridgeNamespace;
+  STATEFUL_RATE_LIMITER: RateLimit;
+  MBM_ALLOWED_ORIGINS?: string;
+}
+
+const logOuterFetchFailure = createThrottledEdgeLogger();
+
+export async function handleOuterWorkerFetch(
+  request: Request,
+  env: OuterWorkerEnv,
+  ctx: ExecutionContext,
+  identity: { server: string; version: string },
+): Promise<Response> {
+  const extraOrigins = env.MBM_ALLOWED_ORIGINS ?? "";
+  const staticResponse = respondWithoutDurableObject(request, identity, extraOrigins);
+  if (staticResponse) return staticResponse;
+
+  try {
+    const limited = await admitStatefulRequest(request, env.STATEFUL_RATE_LIMITER, extraOrigins);
+    if (limited) return limited;
+    const stub = env.BRIDGE.getByName("default");
+    const streamed = await proxyMcpEventStream({ request, bridge: stub, extraOrigins, ctx });
+    return streamed ?? stub.fetch(sanitizeBridgeRequest(request));
+  } catch (error) {
+    if (isDurableObjectQuotaError(error)) return durableObjectQuotaResponse(request, extraOrigins);
+    logOuterFetchFailure("error", "outer.fetch.failed", {
+      path: new URL(request.url).pathname,
+      error_class: outerWorkerErrorClass(error),
+    });
+    return workerGatewayErrorResponse(request, extraOrigins);
+  }
+}