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

package/src/worker/mcp-modern-proxy.ts

@@ -0,0 +1,126 @@
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { MCP_MODERN_PROTOCOL_VERSION } from "../shared/mcp-protocol.mjs";
+import { randomToken } from "./oauth-state.ts";
+import { acceptsEventStream } from "./mcp-stream.ts";
+import {
+  withProxyHeaders, type BridgeFetcher, type StreamExecutionContext,
+} from "./mcp-stream-proxy-contract.ts";
+
+const HEARTBEAT_MS = Number(relayContract.streamHeartbeatMs);
+const HEARTBEAT = new TextEncoder().encode(": heartbeat\n\n");
+
+export async function proxyModernMcpStream(input: {
+  request: Request;
+  bridge: BridgeFetcher;
+  ctx: StreamExecutionContext;
+}): Promise<Response | null> {
+  const version = input.request.headers.get("MCP-Protocol-Version")?.trim() ?? "";
+  if (version !== MCP_MODERN_PROTOCOL_VERSION
+    || input.request.method !== "POST"
+    || !acceptsEventStream(input.request)) return null;
+
+  const streamId = randomToken("stream");
+  const upstreamController = new AbortController();
+  let earlyAbortReason: unknown;
+  const earlyAbort = () => {
+    earlyAbortReason = input.request.signal.reason ?? "client request aborted";
+    upstreamController.abort(earlyAbortReason);
+  };
+  input.request.signal.addEventListener("abort", earlyAbort, { once: true });
+  if (input.request.signal.aborted) earlyAbort();
+
+  let upstream: Response;
+  try {
+    upstream = await input.bridge.fetch(withProxyHeaders(
+      input.request, "modern-direct", streamId, upstreamController.signal,
+    ));
+  } catch (error) {
+    input.request.signal.removeEventListener("abort", earlyAbort);
+    if (earlyAbortReason !== undefined) input.ctx.waitUntil(cancelModernCall(input.bridge, input.request, streamId));
+    throw error;
+  }
+  if (!upstream.body || !upstream.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream")) {
+    input.request.signal.removeEventListener("abort", earlyAbort);
+    if (earlyAbortReason !== undefined) input.ctx.waitUntil(cancelModernCall(input.bridge, input.request, streamId));
+    return upstream;
+  }
+
+  const reader = upstream.body.getReader();
+  let closed = false;
+  let heartbeat: ReturnType<typeof setInterval> | undefined;
+  const finish = () => {
+    if (closed) return false;
+    closed = true;
+    if (heartbeat) clearInterval(heartbeat);
+    input.request.signal.removeEventListener("abort", abort);
+    return true;
+  };
+  const cancel = (reason: unknown): boolean => {
+    if (!finish()) return false;
+    upstreamController.abort(reason);
+    void reader.cancel(reason).catch(() => {}).finally(() => releaseReaderQuietly(reader));
+    input.ctx.waitUntil(cancelModernCall(input.bridge, input.request, streamId));
+    return true;
+  };
+  const abort = () => cancel(input.request.signal.reason ?? "client request aborted");
+  input.request.signal.removeEventListener("abort", earlyAbort);
+  input.request.signal.addEventListener("abort", abort, { once: true });
+  if (earlyAbortReason !== undefined) cancel(earlyAbortReason);
+
+  const body = new ReadableStream<Uint8Array>({
+    start(target) {
+      if (closed) {
+        target.close();
+        return;
+      }
+      heartbeat = setInterval(() => {
+        if (closed) return;
+        try { target.enqueue(HEARTBEAT); }
+        catch { cancel("public response stream closed"); }
+      }, HEARTBEAT_MS);
+      void pumpUpstream(reader, target, finish, cancel);
+    },
+    cancel(reason) { cancel(reason); },
+  });
+  return new Response(body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: new Headers(upstream.headers),
+  });
+}
+
+async function pumpUpstream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  target: ReadableStreamDefaultController<Uint8Array>,
+  finish: () => boolean,
+  cancel: (reason: unknown) => boolean,
+): Promise<void> {
+  try {
+    for (;;) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        if (finish()) target.close();
+        return;
+      }
+      target.enqueue(chunk.value);
+    }
+  } catch (error) {
+    if (!cancel(error)) return;
+    try { target.error(error); } catch { /* The public response already closed. */ }
+  } finally {
+    releaseReaderQuietly(reader);
+  }
+}
+
+function releaseReaderQuietly(reader: ReadableStreamDefaultReader<Uint8Array>): void {
+  try { reader.releaseLock(); } catch { /* The reader may already be released by cancellation cleanup. */ }
+}
+
+async function cancelModernCall(bridge: BridgeFetcher, request: Request, streamId: string): Promise<void> {
+  try {
+    const control = new Request(request.url, { method: "POST" });
+    await bridge.fetch(withProxyHeaders(control, "modern-cancel", streamId));
+  } catch {
+    // The daemon call retains its bounded operation timeout if cancellation delivery fails.
+  }
+}

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

@@ -0,0 +1,71 @@
+import { subscriptionAcknowledgedNotification, subscriptionCompleteResult } from "../shared/mcp-subscriptions.mjs";
+import { rpcResult, type JsonRpcId } from "./mcp-jsonrpc.ts";
+
+export function modernSubscriptionResponse(input: {
+  requestId: Exclude<JsonRpcId, null>;
+  notifications: Record<string, unknown>;
+  serverInfo: Record<string, unknown>;
+}): Response {
+  const encoder = new TextEncoder();
+  const acknowledged = subscriptionAcknowledgedNotification(input.requestId, input.notifications);
+  const complete = rpcResult(input.requestId, subscriptionCompleteResult(input.requestId, input.serverInfo));
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(sseMessage(acknowledged)));
+      controller.enqueue(encoder.encode(sseMessage(complete)));
+      controller.close();
+    },
+  });
+  return modernEventStreamResponse(body);
+}
+
+export function modernJsonRpcResponseStream(
+  result: Promise<Record<string, unknown>>,
+  options: { onCancel: () => void; onError: (error: unknown) => Record<string, unknown> },
+): Response {
+  const encoder = new TextEncoder();
+  let writable = true;
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(": connected\n\n"));
+      void result.then(
+        (message) => {
+          if (!writable) return;
+          try { controller.enqueue(encoder.encode(sseMessage(message))); } catch { writable = false; }
+          if (!writable) return;
+          writable = false;
+          try { controller.close(); } catch { /* Client already closed the response stream. */ }
+        },
+        (error) => {
+          if (!writable) return;
+          try { controller.enqueue(encoder.encode(sseMessage(options.onError(error)))); } catch { writable = false; }
+          if (!writable) return;
+          writable = false;
+          try { controller.close(); } catch { /* Client already closed the response stream. */ }
+        },
+      );
+    },
+    cancel() {
+      if (!writable) return;
+      writable = false;
+      options.onCancel();
+    },
+  });
+  return modernEventStreamResponse(body);
+}
+
+function modernEventStreamResponse(body: ReadableStream<Uint8Array>): Response {
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-store, no-transform",
+      "x-accel-buffering": "no",
+      "x-content-type-options": "nosniff",
+    },
+  });
+}
+
+function sseMessage(message: unknown): string {
+  return `event: message\ndata: ${JSON.stringify(message)}\n\n`;
+}

package/src/worker/mcp-session.ts

@@ -66,7 +66,16 @@ export async function resolveMcpSession(
   return { kind: "active", sessionId };
 }
 
-export function mcpClientRequestKey(tokenKey: string, sessionId: string, requestId: unknown): string | undefined {
-  if (!sessionId || requestId === null || (typeof requestId !== "string" && typeof requestId !== "number")) return undefined;
-  return `${tokenKey}:${sessionId}:${typeof requestId}:${String(requestId)}`;
+export function legacyMcpClientRequestKey(tokenKey: string, sessionId: string, requestId: unknown): string | undefined {
+  if (!sessionId || !isRequestId(requestId)) return undefined;
+  return `${tokenKey}:legacy:${sessionId}:${typeof requestId}:${String(requestId)}`;
+}
+
+export function modernMcpStreamRequestKey(streamId: string): string | undefined {
+  if (!/^stream_[A-Za-z0-9_-]{43}$/.test(streamId)) return undefined;
+  return `modern:${streamId}`;
+}
+
+function isRequestId(value: unknown): value is string | number {
+  return typeof value === "string" || (typeof value === "number" && Number.isFinite(value));
 }

package/src/worker/mcp-stream-proxy-contract.ts

@@ -0,0 +1,67 @@
+import { json } from "./http.ts";
+
+export const MCP_STREAM_PROXY_MODE_HEADER = "x-machine-bridge-internal-mcp-stream-mode";
+export const MCP_STREAM_PROXY_ID_HEADER = "x-machine-bridge-internal-mcp-stream-id";
+export const MCP_STREAM_DESCRIPTOR_HEADER = "x-machine-bridge-mcp-stream-descriptor";
+const STREAM_ID_PATTERN = /^stream_[A-Za-z0-9_-]{43}$/;
+
+export type StreamProxyMode = "prepare" | "subscribe" | "modern-direct" | "modern-cancel" | "";
+export type StreamDescriptorKind = "initial" | "resume" | "complete";
+export type StreamDescriptor = { kind: StreamDescriptorKind; stream_id: string };
+export type BridgeFetcher = { fetch(request: Request): Promise<Response> };
+export type StreamExecutionContext = { waitUntil(promise: Promise<unknown>): void };
+
+export function sanitizeBridgeRequest(request: Request): Request {
+  const headers = new Headers(request.headers);
+  headers.delete(MCP_STREAM_PROXY_MODE_HEADER);
+  headers.delete(MCP_STREAM_PROXY_ID_HEADER);
+  return new Request(request, { headers });
+}
+
+export function mcpStreamProxyMode(request: Pick<Request, "headers">): StreamProxyMode {
+  const value = request.headers.get(MCP_STREAM_PROXY_MODE_HEADER)?.trim().toLowerCase() ?? "";
+  return value === "prepare" || value === "subscribe" || value === "modern-direct" || value === "modern-cancel" ? value : "";
+}
+
+export function mcpStreamProxyId(request: Pick<Request, "headers">): string {
+  const value = request.headers.get(MCP_STREAM_PROXY_ID_HEADER)?.trim() ?? "";
+  return STREAM_ID_PATTERN.test(value) ? value : "";
+}
+
+export function mcpStreamDescriptorResponse(kind: StreamDescriptorKind, streamId: string): Response {
+  if (!STREAM_ID_PATTERN.test(streamId)) throw new Error("invalid MCP stream descriptor id");
+  return json({ kind, stream_id: streamId }, 200, { [MCP_STREAM_DESCRIPTOR_HEADER]: "1" });
+}
+
+export function withProxyHeaders(
+  request: Request,
+  mode: Exclude<StreamProxyMode, "">,
+  streamId = "",
+  signal?: AbortSignal,
+): Request {
+  const sanitized = sanitizeBridgeRequest(request);
+  const headers = new Headers(sanitized.headers);
+  headers.set(MCP_STREAM_PROXY_MODE_HEADER, mode);
+  if (streamId) headers.set(MCP_STREAM_PROXY_ID_HEADER, streamId);
+  if (mode === "subscribe") headers.set("Upgrade", "websocket");
+  const method = mode === "subscribe" ? "GET" : mode === "modern-cancel" ? "POST" : sanitized.method;
+  return new Request(sanitized, { method, headers, signal: signal ?? sanitized.signal });
+}
+
+export async function readDescriptor(response: Response): Promise<StreamDescriptor> {
+  const value: unknown = await response.json();
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("MCP stream descriptor is invalid");
+  const kind = (value as { kind?: unknown }).kind;
+  const streamId = (value as { stream_id?: unknown }).stream_id;
+  if ((kind !== "initial" && kind !== "resume" && kind !== "complete")
+    || typeof streamId !== "string" || !STREAM_ID_PATTERN.test(streamId)) {
+    throw new Error("MCP stream descriptor is invalid");
+  }
+  return { kind, stream_id: streamId };
+}
+
+export function stripInternalResponseHeaders(response: Response): Response {
+  const headers = new Headers(response.headers);
+  headers.delete(MCP_STREAM_DESCRIPTOR_HEADER);
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}

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

@@ -1,18 +1,20 @@
+import { MCP_MODERN_PROTOCOL_VERSION } from "../shared/mcp-protocol.mjs";
 import { applyCors, baseUrl, json } from "./http.ts";
 import { acceptsEventStream, resumeJsonRpcResponse, streamJsonRpcResponse } from "./mcp-stream.ts";
 import type { McpStreamChannel } from "./mcp-stream-channel.ts";
+import { proxyModernMcpStream } from "./mcp-modern-proxy.ts";
 import { DEFAULT_SUBSCRIBE_RETRY_DELAYS_MS, subscribeTerminalMessage } from "./mcp-stream-subscription.ts";
+import {
+  MCP_STREAM_DESCRIPTOR_HEADER, mcpStreamProxyId, mcpStreamProxyMode, readDescriptor,
+  stripInternalResponseHeaders, withProxyHeaders,
+  type BridgeFetcher, type StreamExecutionContext,
+} from "./mcp-stream-proxy-contract.ts";
 
-export const MCP_STREAM_PROXY_MODE_HEADER = "x-machine-bridge-internal-mcp-stream-mode";
-export const MCP_STREAM_PROXY_ID_HEADER = "x-machine-bridge-internal-mcp-stream-id";
-const MCP_STREAM_DESCRIPTOR_HEADER = "x-machine-bridge-mcp-stream-descriptor";
-const STREAM_ID_PATTERN = /^stream_[A-Za-z0-9_-]{43}$/;
-
-type StreamProxyMode = "prepare" | "subscribe" | "";
-type StreamDescriptorKind = "initial" | "resume" | "complete";
-type StreamDescriptor = { kind: StreamDescriptorKind; stream_id: string };
-type BridgeFetcher = { fetch(request: Request): Promise<Response> };
-type StreamExecutionContext = { waitUntil(promise: Promise<unknown>): void };
+export {
+  MCP_STREAM_PROXY_ID_HEADER, MCP_STREAM_PROXY_MODE_HEADER,
+  mcpStreamDescriptorResponse, mcpStreamProxyId, mcpStreamProxyMode, sanitizeBridgeRequest,
+} from "./mcp-stream-proxy-contract.ts";
+export type { StreamProxyMode } from "./mcp-stream-proxy-contract.ts";
 
 export async function proxyMcpEventStream(input: {
   request: Request;
@@ -22,10 +24,13 @@ export async function proxyMcpEventStream(input: {
   subscribeRetryDelaysMs?: readonly number[];
 }): Promise<Response | null> {
   const url = new URL(input.request.url);
+  if (url.pathname !== "/mcp") return null;
+  const protocolVersion = input.request.headers.get("MCP-Protocol-Version")?.trim() ?? "";
+  if (protocolVersion === MCP_MODERN_PROTOCOL_VERSION) return proxyModernMcpStream(input);
+
   const eligible = input.request.method === "GET"
     || (input.request.method === "POST" && acceptsEventStream(input.request));
-  if (url.pathname !== "/mcp" || !eligible) return null;
-
+  if (!eligible) return null;
   const prepared = await input.bridge.fetch(withProxyHeaders(input.request, "prepare"));
   if (prepared.headers.get(MCP_STREAM_DESCRIPTOR_HEADER) !== "1") return stripInternalResponseHeaders(prepared);
   const descriptor = await readDescriptor(prepared);
@@ -64,51 +69,3 @@ export async function handleMcpStreamSubscribeRequest(
   if (!streamId) return json({ error: "invalid_internal_stream_id" }, 400);
   return await channel.subscribe(request, streamId, resumption);
 }
-
-export function sanitizeBridgeRequest(request: Request): Request {
-  const headers = new Headers(request.headers);
-  headers.delete(MCP_STREAM_PROXY_MODE_HEADER);
-  headers.delete(MCP_STREAM_PROXY_ID_HEADER);
-  return new Request(request, { headers });
-}
-
-export function mcpStreamProxyMode(request: Request): StreamProxyMode {
-  const value = request.headers.get(MCP_STREAM_PROXY_MODE_HEADER)?.trim().toLowerCase() ?? "";
-  return value === "prepare" || value === "subscribe" ? value : "";
-}
-
-export function mcpStreamProxyId(request: Request): string {
-  const value = request.headers.get(MCP_STREAM_PROXY_ID_HEADER)?.trim() ?? "";
-  return STREAM_ID_PATTERN.test(value) ? value : "";
-}
-
-export function mcpStreamDescriptorResponse(kind: StreamDescriptorKind, streamId: string): Response {
-  if (!STREAM_ID_PATTERN.test(streamId)) throw new Error("invalid MCP stream descriptor id");
-  return json({ kind, stream_id: streamId }, 200, { [MCP_STREAM_DESCRIPTOR_HEADER]: "1" });
-}
-
-function withProxyHeaders(request: Request, mode: Exclude<StreamProxyMode, "">, streamId = ""): Request {
-  const sanitized = sanitizeBridgeRequest(request);
-  const headers = new Headers(sanitized.headers);
-  headers.set(MCP_STREAM_PROXY_MODE_HEADER, mode);
-  if (streamId) headers.set(MCP_STREAM_PROXY_ID_HEADER, streamId);
-  if (mode === "subscribe") headers.set("Upgrade", "websocket");
-  return new Request(sanitized, { method: mode === "subscribe" ? "GET" : sanitized.method, headers });
-}
-
-async function readDescriptor(response: Response): Promise<StreamDescriptor> {
-  const value: unknown = await response.json();
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("MCP stream descriptor is invalid");
-  const kind = (value as { kind?: unknown }).kind;
-  const streamId = (value as { stream_id?: unknown }).stream_id;
-  if ((kind !== "initial" && kind !== "resume" && kind !== "complete") || typeof streamId !== "string" || !STREAM_ID_PATTERN.test(streamId)) {
-    throw new Error("MCP stream descriptor is invalid");
-  }
-  return { kind, stream_id: streamId };
-}
-
-function stripInternalResponseHeaders(response: Response): Response {
-  const headers = new Headers(response.headers);
-  headers.delete(MCP_STREAM_DESCRIPTOR_HEADER);
-  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
-}

package/src/worker/mcp-tool-call-input.ts

@@ -0,0 +1,23 @@
+import { validateWorkerToolArguments } from "./tool-catalog.ts";
+import { asObject } from "./mcp-jsonrpc.ts";
+
+type ToolDefinition = Readonly<{ name?: unknown }>;
+type ValidationIssue = Readonly<{ instancePath: string; keyword: string; message: string }>;
+
+export type WorkerToolCallInput =
+  | Readonly<{ ok: true; name: string; args: Record<string, unknown> }>
+  | Readonly<{ ok: false; reason: "missing_name" | "unknown_tool" | "invalid_arguments"; issues?: readonly ValidationIssue[] }>;
+
+export function inspectWorkerToolCall(paramsValue: unknown, advertisedTools: readonly ToolDefinition[]): WorkerToolCallInput {
+  const params = asObject(paramsValue);
+  const name = typeof params.name === "string" && params.name.trim() ? params.name.trim() : "";
+  if (!name) return Object.freeze({ ok: false, reason: "missing_name" });
+  if (!advertisedTools.some((tool) => tool.name === name)) return Object.freeze({ ok: false, reason: "unknown_tool" });
+  const rawArgs = params.arguments === undefined ? {} : params.arguments;
+  const validation = validateWorkerToolArguments(name, rawArgs);
+  if (!validation.known) return Object.freeze({ ok: false, reason: "unknown_tool" });
+  if (!validation.valid) {
+    return Object.freeze({ ok: false, reason: "invalid_arguments", issues: validation.issues });
+  }
+  return Object.freeze({ ok: true, name, args: rawArgs as Record<string, unknown> });
+}

package/src/worker/tool-catalog.ts

@@ -1,11 +1,39 @@
 import toolCatalog from "../shared/tool-catalog.json" with { type: "json" };
+import { compileToolArgumentValidators } from "../shared/tool-argument-validation.mjs";
+import { toolParameterHeaderNames } from "./mcp-http-contract.ts";
+import {
+  isConfigurableForegroundTool,
+  remoteForegroundDefaultSeconds,
+  REMOTE_FOREGROUND_TIMEOUT_SECONDS,
+} from "./tool-timeout.ts";
 
 export type WorkerToolDefinition = Record<string, unknown> & { name: string; availability?: string };
+type JsonSchema = Record<string, unknown> & { properties: Record<string, Record<string, unknown>> };
 
 const allTools = toolCatalog as WorkerToolDefinition[];
 
 export const serverInfoTool = publicTool(allTools.find((tool) => tool.name === "server_info")!);
-export const workspaceTools = Object.freeze(allTools.filter((tool) => tool.name !== "server_info").map(publicTool));
+export const workspaceTools = Object.freeze(allTools.filter((tool) => tool.name !== "server_info").map(remotePublicTool));
+
+const publicTools = [serverInfoTool, ...workspaceTools];
+const workerToolArguments = compileToolArgumentValidators(publicTools);
+export const workerToolParameterHeaders = toolParameterHeaderNames(publicTools);
+
+export function validateWorkerToolArguments(name: unknown, value: unknown) {
+  return workerToolArguments.validate(name, value);
+}
+
+function remotePublicTool(tool: WorkerToolDefinition): WorkerToolDefinition {
+  const definition = publicTool(tool);
+  if (!isConfigurableForegroundTool(definition.name)) return definition;
+
+  const schema = definition.inputSchema as JsonSchema;
+  const timeout = schema.properties.timeout_seconds;
+  timeout.maximum = REMOTE_FOREGROUND_TIMEOUT_SECONDS;
+  timeout.default = remoteForegroundDefaultSeconds(definition.name);
+  definition.description = `${String(definition.description)} Remote foreground execution is limited to ${REMOTE_FOREGROUND_TIMEOUT_SECONDS} seconds; use process sessions or managed jobs for longer work.`;
+  return definition;
+}
 
 function publicTool(tool: WorkerToolDefinition): WorkerToolDefinition {
   const { availability: _availability, ...definition } = tool;

package/src/worker/tool-timeout.ts

@@ -1,21 +1,62 @@
 import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { WorkerToolError } from "./errors.ts";
+
+const CONFIGURABLE_FOREGROUND_TOOLS = new Set([
+  "exec_command", "run_process", "run_local_command", "open_local_application",
+  "inspect_local_application", "operate_local_application", "browser_list_tabs",
+  "browser_manage_tabs", "browser_wait", "browser_get_source", "browser_inspect_page",
+  "browser_action", "browser_fill_form", "browser_screenshot", "browser_upload_files",
+]);
+
+export const REMOTE_FOREGROUND_TIMEOUT_SECONDS = Math.floor(
+  relayContract.maximumInteractiveExecutionTimeoutMs / 1000,
+);
+const THIRTY_SECOND_FOREGROUND_TOOLS = new Set([
+  "open_local_application", "inspect_local_application", "operate_local_application",
+  "browser_list_tabs", "browser_manage_tabs", "browser_wait", "browser_get_source",
+  "browser_inspect_page", "browser_action", "browser_screenshot",
+]);
+
+export function isConfigurableForegroundTool(name: string): boolean {
+  return CONFIGURABLE_FOREGROUND_TOOLS.has(name);
+}
+
+export function remoteForegroundDefaultSeconds(name: string): number {
+  return THIRTY_SECOND_FOREGROUND_TOOLS.has(name) ? 30 : 60;
+}
 
 export function daemonToolTimeoutMs(name: string, args: Record<string, unknown>): number {
   if (name === "session_bootstrap") return 10_000;
-  const configurable = new Set([
-    "exec_command", "run_process", "run_local_command", "open_local_application",
-    "inspect_local_application", "operate_local_application", "browser_list_tabs",
-    "browser_manage_tabs", "browser_wait", "browser_get_source", "browser_inspect_page",
-    "browser_action", "browser_fill_form", "browser_screenshot", "browser_upload_files",
-  ]);
-  if (!configurable.has(name)) return 60_000;
-  const seconds = clampNumber(args.timeout_seconds, name === "browser_fill_form" ? 60 : 120, 1, 600);
+  if (!isConfigurableForegroundTool(name)) return 60_000;
+
+  const seconds = remoteForegroundSeconds(name, args.timeout_seconds);
   const executionMs = Math.min(seconds * 1000, relayContract.maximumExecutionTimeoutMs);
   return Math.min(executionMs + relayContract.toolCallOverheadMs, relayContract.maximumRelayToolTimeoutMs);
 }
 
-function clampNumber(value: unknown, fallback: number, min: number, max: number): number {
-  const number = typeof value === "number" && Number.isFinite(value) ? value : Number.parseInt(String(value ?? ""), 10);
-  const safe = Number.isFinite(number) ? number : fallback;
-  return Math.min(Math.max(Math.floor(safe), min), max);
+function remoteForegroundSeconds(name: string, value: unknown): number {
+  if (value === undefined) return remoteForegroundDefaultSeconds(name);
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    throw foregroundTimeoutError("remote foreground timeout must be an integer of at least 1 second");
+  }
+  if (value > REMOTE_FOREGROUND_TIMEOUT_SECONDS) {
+    throw foregroundTimeoutError(
+      `remote foreground timeout exceeds ${REMOTE_FOREGROUND_TIMEOUT_SECONDS} seconds; split mutations from verification and use start_process/read_process or start_job/read_job for longer work`,
+    );
+  }
+  return value;
+}
+
+function foregroundTimeoutError(message: string): WorkerToolError {
+  return new WorkerToolError(
+    "invalid_request",
+    message,
+    false,
+    {
+      side_effects_started: false,
+      minimum_foreground_timeout_seconds: 1,
+      maximum_foreground_timeout_seconds: REMOTE_FOREGROUND_TIMEOUT_SECONDS,
+      recommended_tools: ["start_process", "read_process", "start_job", "read_job"],
+    },
+  );
 }

package/src/worker/worker-mcp-config.ts

@@ -0,0 +1,23 @@
+import serverMetadata from "../shared/server-metadata.json" with { type: "json" };
+import { serverImplementation } from "../shared/mcp-protocol.mjs";
+
+export const SERVER_NAME = String(serverMetadata.name);
+export const MCP_MODERN_PROTOCOL_VERSIONS = Object.freeze(
+  serverMetadata.modernProtocolVersions.map((value) => String(value)),
+);
+export const MCP_LEGACY_PROTOCOL_VERSIONS = Object.freeze(
+  serverMetadata.legacyProtocolVersions.map((value) => String(value)),
+);
+export const MCP_INSTRUCTIONS = serverMetadata.instructions.map((value) => String(value)).join("\n");
+export const MCP_SERVER_CAPABILITIES = Object.freeze({ tools: Object.freeze({ listChanged: false }) });
+export const MCP_DISCOVERY_TTL_MS = 300_000;
+export const MCP_TOOL_LIST_TTL_MS = 300_000;
+
+export function mcpServerInfo(version: string): Readonly<Record<string, unknown>> {
+  return Object.freeze(serverImplementation({
+    name: SERVER_NAME,
+    title: "Machine Bridge MCP",
+    version,
+    description: "Workspace-scoped local coding tools over authenticated remote relay.",
+  }));
+}

package/src/worker/worker-metadata.ts

@@ -8,7 +8,16 @@ export function mcpMetadata(base: string, identity: WorkerIdentity): Record<stri
     version: identity.version,
     protocolVersion: String(serverMetadata.protocolVersion),
     protocolVersions: serverMetadata.supportedProtocolVersions.map((value) => String(value)),
-    transport: { type: "streamable-http", url: `${base}/mcp` },
+    protocolEras: {
+      modern: serverMetadata.modernProtocolVersions.map((value) => String(value)),
+      legacy: serverMetadata.legacyProtocolVersions.map((value) => String(value)),
+    },
+    transport: {
+      type: "streamable-http",
+      url: `${base}/mcp`,
+      modern: { methods: ["POST"], protocolSessions: false, resumableSse: false },
+      legacy: { methods: ["GET", "POST"], protocolSessions: true, resumableSse: true },
+    },
     auth: { type: "oauth", authorization_servers: [base] },
   };
 }

package/src/worker/worker-runtime-config.ts

@@ -0,0 +1,19 @@
+import type { OAuthControllerEnv } from "./oauth-controller.ts";
+
+const DEFAULT_MAX_BODY_BYTES = 8 * 1024 * 1024;
+const MAX_BODY_BYTES = 16 * 1024 * 1024;
+
+export interface BridgeEnv extends OAuthControllerEnv {
+  BRIDGE: DurableObjectNamespace;
+  DAEMON_DEVICE_PUBLIC_KEY: string;
+  OAUTH_TOKEN_VERSION: string;
+  MBM_WORKER_MAX_BODY_BYTES?: string;
+  MBM_ALLOWED_ORIGINS?: string;
+  STATEFUL_RATE_LIMITER: RateLimit;
+}
+
+export function workerBodyLimitBytes(configured: string | undefined): number {
+  const parsed = Number.parseInt(configured ?? "", 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MAX_BODY_BYTES;
+  return Math.min(parsed, MAX_BODY_BYTES);
+}

package/src/worker/worker-static-routes.ts

@@ -1,4 +1,5 @@
-import { applyCors, baseUrl, corsPreflight, json, methodNotAllowed } from "./http.ts";
+import { applyCors, baseUrl, corsPreflight, json, mcpOriginRejection, methodNotAllowed } from "./http.ts";
+import { workerToolParameterHeaders } from "./tool-catalog.ts";
 import {
   authorizationServerMetadata, mcpMetadata, protectedResourceMetadata, type WorkerIdentity,
 } from "./worker-metadata.ts";
@@ -25,7 +26,11 @@ export function respondWithoutDurableObject(request: Request, identity: WorkerId
   const url = new URL(request.url);
   const base = baseUrl(request);
   const path = url.pathname;
-  if (request.method === "OPTIONS" && request.headers.has("Origin")) return corsPreflight(request, base, extraOrigins);
+  if (request.method === "OPTIONS" && request.headers.has("Origin")) return corsPreflight(request, base, extraOrigins, workerToolParameterHeaders);
+  if (path === "/mcp") {
+    const originRejection = mcpOriginRejection(request, base, extraOrigins);
+    if (originRejection) return originRejection;
+  }
   const statefulMethods = STATEFUL_METHODS.get(path);
   if (statefulMethods) {
     const allowed = new Set(statefulMethods.split(",").map((method) => method.trim()));

package/tsconfig.local.json

@@ -28,6 +28,12 @@
     "src/local/agent-context-projection.mjs",
     "src/local/agent-skill-discovery.mjs",
     "src/local/agent-text-file.mjs",
-    "src/local/managed-job-projection.mjs"
+    "src/local/managed-job-projection.mjs",
+    "src/local/child-process-settlement.mjs",
+    "src/local/system-network-route.mjs",
+    "src/local/process-tree-ownership.mjs",
+    "src/local/service-owner.mjs",
+    "src/local/service-runtime.mjs",
+    "src/local/windows-service-convergence.mjs"
   ]
 }