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

package/src/local/windows-service.mjs

@@ -1,11 +1,7 @@
 import { waitForInactiveStatus } from "./service-convergence.mjs";
-import {
-  windowsLauncherPath, windowsTaskAction, writeWindowsLauncher,
-} from "./windows-launcher.mjs";
-export {
-  windowsBatchArgument, windowsCommandLineArgument, windowsLauncherContent,
-  windowsLauncherPath, windowsTaskAction, writeWindowsLauncher,
-} from "./windows-launcher.mjs";
+import { stableWindowsStatus, waitForWindowsStatus, windowsStatusWaitOptions } from "./windows-service-convergence.mjs";
+import { windowsLauncherPath, windowsTaskAction, writeWindowsLauncher } from "./windows-launcher.mjs";
+export { windowsBatchArgument, windowsCommandLineArgument, windowsLauncherContent, windowsLauncherPath, windowsTaskAction, writeWindowsLauncher } from "./windows-launcher.mjs";
 
 export const WINDOWS_TASK = "MachineBridgeMCP";
 const WINDOWS_STATUS_SCRIPT = [
@@ -28,7 +24,9 @@ export async function installWindowsTask(spec, logger = console, options = {}) {
     "/RL", "LIMITED",
     "/F",
   ]);
-  const status = await waitForWindowsStatus(value => value.installed === true, { ...options, run });
+  const status = await waitForWindowsStatus(
+    () => statusWindowsTask({ ...options, run }), value => value.installed === true, options,
+  );
   const ok = create?.code === 0 && status.installed === true;
   if (ok) logger.info?.("Windows Scheduled Task installed for user logon");
   else logger.warn?.("Windows Scheduled Task installation failed", { reason: windowsServiceFailureReason(create, status) });
@@ -51,35 +49,37 @@ export async function startWindowsTask(logger = console, options = {}) {
   if (before.installed === null) return { ok: false, provider: "schtasks", task: WINDOWS_TASK, reason: "task_status_unavailable", status: before };
   if (before.installed === false) return { ok: false, provider: "schtasks", task: WINDOWS_TASK, reason: "not_installed", status: before };
   if (before.active === true) {
-    logger.info?.("Windows Scheduled Task is already running");
-    return {
-      ok: true,
-      provider: "schtasks",
-      task: WINDOWS_TASK,
-      installed: true,
-      active_before: true,
-      active: true,
-      already_running: true,
-      reason: "already_running",
-      status: before,
-    };
+    const existing = await stableWindowsStatus(() => statusWindowsTask({ ...options, run }), options);
+    if (existing.stable) {
+      logger.info?.("Windows Scheduled Task is already running");
+      return {
+        ok: true, provider: "schtasks", task: WINDOWS_TASK, installed: true,
+        active_before: true, active: true, already_running: true, reason: "already_running", status: existing.status,
+      };
+    }
   }
   const command = await run("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
   const after = await waitForWindowsStatus(
-    status => status.active === true || completedSince(before, status),
-    { ...options, run },
+    () => statusWindowsTask({ ...options, run }),
+    status => status.active === true || completedSince(before, status), options,
   );
-  const completed = completedSince(before, after);
-  const ok = after.active === true || completed;
+  const stability = after.active === true
+    ? await stableWindowsStatus(() => statusWindowsTask({ ...options, run }), options)
+    : { stable: false, status: after };
+  const observed = stability.status;
+  const completed = completedSince(before, observed);
+  const ok = stability.stable;
   if (ok) logger.info?.("Windows Scheduled Task started");
-  else logger.warn?.("Windows Scheduled Task did not reach a running or successful completed state");
+  else logger.warn?.("Windows Scheduled Task did not remain active after the start request");
   return {
     ok,
     provider: "schtasks",
     task: WINDOWS_TASK,
     command,
-    status: after,
-    reason: after.active === true ? "started" : completed ? "completed" : "start_not_observed",
+    status: observed,
+    active_before: false,
+    active: observed?.active === true && stability.stable,
+    reason: stability.stable ? "started" : completed ? "completed_without_persistence" : "start_not_stable",
   };
 }
 export async function restartWindowsTask(logger = console, options = {}) {
@@ -101,6 +101,7 @@ export async function stopWindowsTask(logger = console, options = {}) {
       installed: before.installed,
       active_before: false,
       active: false,
+      restore_required: false,
       already_stopped: true,
       reason: before.installed ? "already_stopped" : "not_installed",
       status: before,
@@ -121,6 +122,7 @@ export async function stopWindowsTask(logger = console, options = {}) {
     installed: after?.installed !== false,
     active_before: true,
     active: after?.active !== false,
+    restore_required: ok,
     already_stopped: false,
     command,
     status: after,
@@ -134,8 +136,7 @@ export async function uninstallWindowsTask(logger = console, options = {}) {
   if (!stopped.ok) return { ok: false, provider: "schtasks", task: WINDOWS_TASK, stop: stopped, reason: "stop_failed" };
   const command = await run("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
   const status = await waitForWindowsStatus(
-    value => value.installed === false,
-    { ...options, run },
+    () => statusWindowsTask({ ...options, run }), value => value.installed === false, options,
   );
   const ok = status.installed === false;
   if (ok) logger.info?.("Windows Scheduled Task removed");
@@ -188,32 +189,8 @@ function windowsServiceFailureReason(command, status) {
   return "task_installation_unverified";
 }
 
-async function waitForWindowsStatus(predicate, options) {
-  const attempts = boundedPositiveInteger(options.statusAttempts, 10);
-  const delayMs = boundedPositiveInteger(options.statusDelayMs, 100);
-  const sleep = typeof options.sleep === "function" ? options.sleep : milliseconds => new Promise(resolve => { setTimeout(resolve, milliseconds); });
-  let status = await statusWindowsTask(options);
-  for (let index = 1; index < attempts && !predicate(status); index += 1) {
-    await sleep(delayMs);
-    status = await statusWindowsTask(options);
-  }
-  return status;
-}
-
-function windowsStatusWaitOptions(options) {
-  return {
-    attempts: boundedPositiveInteger(options.statusAttempts, 10),
-    delayMs: boundedPositiveInteger(options.statusDelayMs, 100),
-    sleep: typeof options.sleep === "function" ? options.sleep : undefined,
-  };
-}
 
 function requiredRun(run) {
   if (typeof run !== "function") throw new Error("Windows service command runner is required");
   return run;
 }
-
-function boundedPositiveInteger(value, fallback) {
-  const number = Number(value);
-  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
-}

package/src/shared/mcp-protocol.d.mts

@@ -0,0 +1,27 @@
+export const MCP_MODERN_PROTOCOL_VERSION: "2026-07-28";
+export const MCP_LEGACY_PROTOCOL_VERSION: "2025-11-25";
+export const MCP_MODERN_PROTOCOL_VERSIONS: readonly string[];
+export const MCP_LEGACY_PROTOCOL_VERSIONS: readonly string[];
+export const MCP_HEADER_MISMATCH: -32020;
+export const MCP_UNSUPPORTED_PROTOCOL_VERSION: -32022;
+export class McpProtocolError extends Error {
+  code: number;
+  data?: unknown;
+  constructor(code: number, message: string, data?: unknown);
+}
+export function asMcpObject(value: unknown): Record<string, any>;
+export function requestProtocolVersion(value: unknown): string;
+export function isModernMcpRequest(value: unknown): boolean;
+export function assertBoundedMcpJsonStructure(value: unknown, label?: string): void;
+export function validateModernRequestMetadata(value: unknown, supportedVersions?: readonly string[]): {
+  version: string;
+  clientCapabilities: Record<string, unknown>;
+  clientInfo: Record<string, unknown> | null;
+  progressToken: unknown;
+  logLevel: unknown;
+};
+export function serverImplementation(input: { name: unknown; version: unknown; title?: unknown; description?: unknown }): Record<string, unknown>;
+export function modernCompleteResult(fields?: Record<string, unknown>, serverInfo?: Record<string, unknown>): Record<string, unknown>;
+export function modernCacheableResult(fields: Record<string, unknown>, options: { ttlMs: number; cacheScope: "public" | "private"; serverInfo?: Record<string, unknown> }): Record<string, unknown>;
+export function modernDiscoverResult(input: { supportedVersions: readonly string[]; capabilities: Record<string, unknown>; instructions?: string; ttlMs?: number; serverInfo?: Record<string, unknown> }): Record<string, unknown>;
+export function resultForProtocol(version: string, fields: Record<string, unknown>, options?: { serverInfo?: Record<string, unknown>; ttlMs?: number; cacheScope?: "public" | "private" }): Record<string, unknown>;

package/src/shared/mcp-protocol.mjs

@@ -0,0 +1,256 @@
+export const MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
+export const MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
+export const MCP_MODERN_PROTOCOL_VERSIONS = Object.freeze([MCP_MODERN_PROTOCOL_VERSION]);
+export const MCP_LEGACY_PROTOCOL_VERSIONS = Object.freeze([MCP_LEGACY_PROTOCOL_VERSION]);
+export const MCP_HEADER_MISMATCH = -32020;
+export const MCP_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+const MCP_RESULT_COMPLETE = "complete";
+
+const PROTOCOL_VERSION_KEY = "io.modelcontextprotocol/protocolVersion";
+const CLIENT_INFO_KEY = "io.modelcontextprotocol/clientInfo";
+const CLIENT_CAPABILITIES_KEY = "io.modelcontextprotocol/clientCapabilities";
+const SERVER_INFO_KEY = "io.modelcontextprotocol/serverInfo";
+const LOG_LEVELS = new Set(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+const META_KEY = /^(?:(?:[A-Za-z](?:[A-Za-z0-9-]*[A-Za-z0-9])?\.)*[A-Za-z](?:[A-Za-z0-9-]*[A-Za-z0-9])?\/)?(?:[A-Za-z0-9](?:[A-Za-z0-9_.-]*[A-Za-z0-9])?)?$/;
+const MAX_MCP_JSON_DEPTH = 32;
+const MAX_MCP_JSON_NODES = 4096;
+const MAX_MCP_JSON_KEY_LENGTH = 256;
+
+export class McpProtocolError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.name = "McpProtocolError";
+    this.code = code;
+    this.data = data;
+  }
+}
+
+export function asMcpObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function requestMeta(value) {
+  return asMcpObject(asMcpObject(value).params)._meta;
+}
+
+export function requestProtocolVersion(value) {
+  const version = asMcpObject(requestMeta(value))[PROTOCOL_VERSION_KEY];
+  return typeof version === "string" ? version : "";
+}
+
+export function isModernMcpRequest(value) {
+  return requestProtocolVersion(value) !== "" || asMcpObject(value).method === "server/discover";
+}
+
+export function validateModernRequestMetadata(value, supportedVersions = MCP_MODERN_PROTOCOL_VERSIONS) {
+  const params = asMcpObject(asMcpObject(value).params);
+  const meta = asMcpObject(params._meta);
+  assertBoundedMcpJsonStructure(meta, "request metadata");
+  const version = meta[PROTOCOL_VERSION_KEY];
+  if (typeof version !== "string" || !version) {
+    throw new McpProtocolError(-32602, `Missing required request metadata: ${PROTOCOL_VERSION_KEY}`);
+  }
+  if (!supportedVersions.includes(version)) {
+    throw new McpProtocolError(MCP_UNSUPPORTED_PROTOCOL_VERSION, "Unsupported protocol version", {
+      supported: [...supportedVersions],
+      requested: boundedProtocolVersion(version),
+    });
+  }
+  validateMetaKeys(meta);
+  const clientCapabilities = meta[CLIENT_CAPABILITIES_KEY];
+  if (!isPlainObject(clientCapabilities)) {
+    throw new McpProtocolError(-32602, `Missing required request metadata: ${CLIENT_CAPABILITIES_KEY}`);
+  }
+  validateClientCapabilities(clientCapabilities);
+  const clientInfo = meta[CLIENT_INFO_KEY];
+  if (clientInfo !== undefined && !isImplementation(clientInfo)) {
+    throw new McpProtocolError(-32602, `Invalid request metadata: ${CLIENT_INFO_KEY}`);
+  }
+  const progressToken = meta.progressToken;
+  if (progressToken !== undefined && !isProgressToken(progressToken)) {
+    throw new McpProtocolError(-32602, "Invalid request metadata: progressToken");
+  }
+  const logLevel = meta["io.modelcontextprotocol/logLevel"];
+  if (logLevel !== undefined && !LOG_LEVELS.has(logLevel)) {
+    throw new McpProtocolError(-32602, "Invalid request metadata: io.modelcontextprotocol/logLevel");
+  }
+  return {
+    version,
+    clientCapabilities,
+    clientInfo: clientInfo ?? null,
+    progressToken,
+    logLevel,
+  };
+}
+
+export function serverImplementation({ name, version, title, description }) {
+  const implementation = { name: String(name), version: String(version) };
+  if (title) implementation.title = String(title);
+  if (description) implementation.description = String(description);
+  return implementation;
+}
+
+export function modernCompleteResult(fields = {}, serverInfo) {
+  return modernResult(MCP_RESULT_COMPLETE, fields, serverInfo);
+}
+
+
+export function modernCacheableResult(fields, { ttlMs, cacheScope, serverInfo }) {
+  const normalizedTtl = Number(ttlMs);
+  if (!Number.isFinite(normalizedTtl) || normalizedTtl < 0) throw new Error("ttlMs must be a non-negative number");
+  if (cacheScope !== "public" && cacheScope !== "private") throw new Error("cacheScope must be public or private");
+  return modernCompleteResult({ ...fields, ttlMs: normalizedTtl, cacheScope }, serverInfo);
+}
+
+export function modernDiscoverResult({ supportedVersions, capabilities, instructions, ttlMs = 0, serverInfo }) {
+  const fields = {
+    supportedVersions: [...supportedVersions],
+    capabilities: structuredClone(capabilities),
+  };
+  if (instructions) fields.instructions = String(instructions);
+  return modernCacheableResult(fields, { ttlMs, cacheScope: "public", serverInfo });
+}
+
+
+export function resultForProtocol(version, fields, { serverInfo, ttlMs, cacheScope } = {}) {
+  if (version !== MCP_MODERN_PROTOCOL_VERSION) return structuredClone(fields);
+  if (ttlMs !== undefined || cacheScope !== undefined) {
+    return modernCacheableResult(fields, {
+      ttlMs: ttlMs ?? 0,
+      cacheScope: cacheScope ?? "private",
+      serverInfo,
+    });
+  }
+  return modernCompleteResult(fields, serverInfo);
+}
+
+function modernServerInfoMeta(serverInfo) {
+  return serverInfo ? { [SERVER_INFO_KEY]: structuredClone(serverInfo) } : undefined;
+}
+
+function modernResult(resultType, fields, serverInfo) {
+  const result = { ...structuredClone(fields), resultType };
+  const meta = modernServerInfoMeta(serverInfo);
+  if (meta) result._meta = { ...asMcpObject(result._meta), ...meta };
+  return result;
+}
+
+
+export function assertBoundedMcpJsonStructure(value, label = "MCP value") {
+  const stack = [{ value, depth: 0 }];
+  let nodes = 0;
+  while (stack.length > 0) {
+    const current = stack.pop();
+    nodes += 1;
+    if (nodes > MAX_MCP_JSON_NODES || current.depth > MAX_MCP_JSON_DEPTH) {
+      throw new McpProtocolError(-32602, `${label} exceeds bounded structural limits`);
+    }
+    if (Array.isArray(current.value)) {
+      if (current.value.length > MAX_MCP_JSON_NODES - nodes - stack.length) {
+        throw new McpProtocolError(-32602, `${label} exceeds bounded structural limits`);
+      }
+      for (let index = 0; index < current.value.length; index += 1) {
+        stack.push({ value: current.value[index], depth: current.depth + 1 });
+      }
+      continue;
+    }
+    if (!current.value || typeof current.value !== "object") continue;
+    if (!isPlainObject(current.value)) throw new McpProtocolError(-32602, `${label} contains a non-JSON object`);
+    for (const key in current.value) {
+      if (!Object.hasOwn(current.value, key)) continue;
+      if (key.length > MAX_MCP_JSON_KEY_LENGTH || stack.length + nodes >= MAX_MCP_JSON_NODES) {
+        throw new McpProtocolError(-32602, `${label} exceeds bounded structural limits`);
+      }
+      stack.push({ value: current.value[key], depth: current.depth + 1 });
+    }
+  }
+}
+
+function validateMetaKeys(meta) {
+  for (const key in meta) {
+    if (!Object.hasOwn(meta, key)) continue;
+    if (key.length > MAX_MCP_JSON_KEY_LENGTH || !META_KEY.test(key)) {
+      throw new McpProtocolError(-32602, "Invalid request metadata key");
+    }
+  }
+}
+
+function validateClientCapabilities(value) {
+  validateCapabilityObject(value, "roots");
+  validateCapabilityMap(value, "experimental");
+  validateCapabilityFields(value, "sampling", ["context", "tools"]);
+  validateCapabilityFields(value, "elicitation", ["form", "url"]);
+  const extensions = value.extensions;
+  if (extensions === undefined) return;
+  if (!isPlainObject(extensions)) throw new McpProtocolError(-32602, "Invalid client capability: extensions");
+  for (const key in extensions) {
+    if (!Object.hasOwn(extensions, key)) continue;
+    const settings = extensions[key];
+    if (key.length > MAX_MCP_JSON_KEY_LENGTH || !key.includes("/") || !META_KEY.test(key) || !isPlainObject(settings)) {
+      throw new McpProtocolError(-32602, "Invalid client extension capability");
+    }
+  }
+}
+
+function validateCapabilityObject(value, key) {
+  if (value[key] !== undefined && !isPlainObject(value[key])) {
+    throw new McpProtocolError(-32602, `Invalid client capability: ${key}`);
+  }
+}
+
+function validateCapabilityMap(value, key) {
+  validateCapabilityObject(value, key);
+  if (value[key] === undefined) return;
+  for (const name in value[key]) {
+    if (!Object.hasOwn(value[key], name)) continue;
+    if (name.length > MAX_MCP_JSON_KEY_LENGTH || !isPlainObject(value[key][name])) {
+      throw new McpProtocolError(-32602, `Invalid client capability: ${key}`);
+    }
+  }
+}
+
+function validateCapabilityFields(value, key, fields) {
+  validateCapabilityObject(value, key);
+  if (value[key] === undefined) return;
+  for (const field of fields) {
+    if (value[key][field] !== undefined && !isPlainObject(value[key][field])) {
+      throw new McpProtocolError(-32602, `Invalid client capability: ${key}.${field}`);
+    }
+  }
+}
+
+function boundedProtocolVersion(value) {
+  return value.length <= 128 ? value : "<invalid-length>";
+}
+
+function isProgressToken(value) {
+  return typeof value === "string" || (typeof value === "number" && Number.isFinite(value));
+}
+
+function isImplementation(value) {
+  if (!isPlainObject(value) || typeof value.name !== "string" || typeof value.version !== "string") return false;
+  for (const field of ["title", "description"]) {
+    if (value[field] !== undefined && typeof value[field] !== "string") return false;
+  }
+  if (value.websiteUrl !== undefined && !isAbsoluteUri(value.websiteUrl)) return false;
+  if (value.icons !== undefined && (!Array.isArray(value.icons) || !value.icons.every(isIcon))) return false;
+  return true;
+}
+
+function isIcon(value) {
+  if (!isPlainObject(value) || !isAbsoluteUri(value.src)) return false;
+  if (value.mimeType !== undefined && typeof value.mimeType !== "string") return false;
+  if (value.sizes !== undefined && (!Array.isArray(value.sizes) || !value.sizes.every((size) => typeof size === "string"))) return false;
+  return value.theme === undefined || value.theme === "light" || value.theme === "dark";
+}
+
+function isAbsoluteUri(value) {
+  if (typeof value !== "string" || !value) return false;
+  try { return Boolean(new URL(value).protocol); } catch { return false; }
+}
+
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}

package/src/shared/mcp-subscriptions.d.mts

@@ -0,0 +1,4 @@
+export function validateSubscriptionFilter(value: unknown): Record<string, unknown>;
+export function acceptedSubscriptionFilter(requested: unknown, serverCapabilities: unknown): Record<string, unknown>;
+export function subscriptionAcknowledgedNotification(subscriptionId: string | number, notifications: Record<string, unknown>): Record<string, unknown>;
+export function subscriptionCompleteResult(subscriptionId: string | number, serverInfo?: Record<string, unknown>): Record<string, unknown>;

package/src/shared/mcp-subscriptions.mjs

@@ -0,0 +1,59 @@
+import {
+  McpProtocolError, asMcpObject, assertBoundedMcpJsonStructure, modernCompleteResult,
+} from "./mcp-protocol.mjs";
+
+const SUBSCRIPTION_ID_KEY = "io.modelcontextprotocol/subscriptionId";
+const MAX_RESOURCE_SUBSCRIPTIONS = 256;
+const MAX_RESOURCE_SUBSCRIPTION_LENGTH = 8192;
+
+export function validateSubscriptionFilter(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new McpProtocolError(-32602, "subscriptions/listen requires a notifications object");
+  }
+  assertBoundedMcpJsonStructure(value, "subscriptions/listen notifications");
+  for (const key of ["toolsListChanged", "promptsListChanged", "resourcesListChanged"]) {
+    if (value[key] !== undefined && typeof value[key] !== "boolean") {
+      throw new McpProtocolError(-32602, `subscriptions/listen notifications.${key} must be boolean`);
+    }
+  }
+  if (value.resourceSubscriptions !== undefined) {
+    if (!Array.isArray(value.resourceSubscriptions)
+      || value.resourceSubscriptions.length > MAX_RESOURCE_SUBSCRIPTIONS
+      || !value.resourceSubscriptions.every((uri) => typeof uri === "string" && uri.length <= MAX_RESOURCE_SUBSCRIPTION_LENGTH)) {
+      throw new McpProtocolError(-32602, "subscriptions/listen notifications.resourceSubscriptions exceeds its bounded string-array contract");
+    }
+  }
+  return value;
+}
+
+export function acceptedSubscriptionFilter(requested, serverCapabilities) {
+  const input = asMcpObject(requested);
+  const capabilities = asMcpObject(serverCapabilities);
+  const tools = asMcpObject(capabilities.tools);
+  const prompts = asMcpObject(capabilities.prompts);
+  const resources = asMcpObject(capabilities.resources);
+  const accepted = {};
+  if (input.toolsListChanged === true && tools.listChanged === true) accepted.toolsListChanged = true;
+  if (input.promptsListChanged === true && prompts.listChanged === true) accepted.promptsListChanged = true;
+  if (input.resourcesListChanged === true && resources.listChanged === true) accepted.resourcesListChanged = true;
+  if (resources.subscribe === true && Array.isArray(input.resourceSubscriptions)) {
+    const uris = input.resourceSubscriptions.filter((value) => typeof value === "string" && value.length > 0);
+    if (uris.length > 0) accepted.resourceSubscriptions = [...new Set(uris)];
+  }
+  return accepted;
+}
+
+export function subscriptionAcknowledgedNotification(subscriptionId, notifications) {
+  return {
+    jsonrpc: "2.0",
+    method: "notifications/subscriptions/acknowledged",
+    params: {
+      _meta: { [SUBSCRIPTION_ID_KEY]: subscriptionId },
+      notifications: structuredClone(notifications),
+    },
+  };
+}
+
+export function subscriptionCompleteResult(subscriptionId, serverInfo) {
+  return modernCompleteResult({ _meta: { [SUBSCRIPTION_ID_KEY]: subscriptionId } }, serverInfo);
+}

package/src/shared/relay-contract.json

@@ -2,6 +2,7 @@
   "reconnectGraceMs": 120000,
   "streamHeartbeatMs": 10000,
   "maximumExecutionTimeoutMs": 600000,
+  "maximumInteractiveExecutionTimeoutMs": 85000,
   "toolCallOverheadMs": 5000,
   "maximumRelayToolTimeoutMs": 610000,
   "streamResumeRetentionMs": 120000,

package/src/shared/result-projection.d.mts

@@ -2,5 +2,6 @@ export const MCP_TEXT_PROJECTION_KEY: "$mcpText";
 export function mirroredResultText(value: unknown): string;
 export function projectMcpResult(value: unknown): {
   text: string;
-  structuredContent: Record<string, unknown> | null;
+  hasStructuredContent: boolean;
+  structuredContent: unknown;
 };

package/src/shared/result-projection.mjs

@@ -35,14 +35,25 @@ export function projectMcpResult(value) {
     const structuredContent = { ...object };
     const text = String(structuredContent[MCP_TEXT_PROJECTION_KEY]).slice(0, 4096);
     delete structuredContent[MCP_TEXT_PROJECTION_KEY];
-    return { text, structuredContent };
+    return { text, hasStructuredContent: true, structuredContent };
   }
   return {
     text: mirroredResultText(value),
-    structuredContent: value && typeof value === "object" && !Array.isArray(value) ? value : null,
+    hasStructuredContent: isJsonValue(value),
+    structuredContent: value,
   };
 }
 
+/** @param {unknown} value */
+function isJsonValue(value) {
+  return value === null
+    || typeof value === "string"
+    || typeof value === "boolean"
+    || (typeof value === "number" && Number.isFinite(value))
+    || Array.isArray(value)
+    || (value && typeof value === "object");
+}
+
 /** @param {unknown} value */
 function asObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};

package/src/shared/server-metadata.json

@@ -1,14 +1,15 @@
 {
   "name": "machine-bridge-mcp",
-  "protocolVersion": "2025-11-25",
+  "protocolVersion": "2026-07-28",
   "supportedProtocolVersions": [
+    "2026-07-28",
     "2025-11-25"
   ],
   "instructions": [
     "You are connected to a local workspace through machine-bridge-mcp.",
-    "At the start of each substantive local task, call resolve_task_capabilities with the current user request and target path. Apply the returned session/project instructions, follow the automatically selected relevant skill when present, and prefer registered local commands for repeatable workflows.",
+    "At the start of each substantive local task, call resolve_task_capabilities with the current user request and target path. Its execution_routing is bounded, set-level, and advisory: direct Bash remains the general escape hatch whenever the effective policy allows it. Reuse refresh.fingerprint as known_refresh_fingerprint to avoid repeating unchanged static instructions. MCP transport connections are not conversation identity; refresh task-specific ranking explicitly rather than assuming prior requests established context.",
     "Before any GitHub read or mutation, apply the effective project control-plane instructions. When a project requires local git, gh, and gh api through Machine Bridge, never use a hosted GitHub connector or ChatGPT GitHub plugin; if the local control plane is unavailable, stop rather than substitute another GitHub tool.",
-    "The MCP initialize response automatically appends conservative built-in working agreements, bounded automatic project facts, the configured global model_instructions_file, and the current root instruction chain when the local daemon is reachable; session_bootstrap exposes the same material explicitly.",
+    "MCP 2026-07-28 clients use server/discover and per-request metadata. The discovery result includes conservative built-in working agreements; session_bootstrap remains an explicit refresh tool for project facts, local instructions, and capability routing. Legacy 2025-11-25 initialize clients receive the same guidance through the compatibility adapter.",
     "For existing-browser work, use the paired Machine Bridge browser extension. It operates the user current Chromium profile and tabs, can inspect DOM/source, fill complex forms, and inject sensitive text from registered local resources without returning those values.",
     "For local application work, use structured application discovery and Accessibility actions. Arbitrary caller-supplied AppleScript or JavaScript is intentionally not accepted.",
     "Remote mode uses a Cloudflare relay; stdio mode runs on the local machine. File and command operations execute on the user's local runtime, not in the Worker.",
@@ -24,8 +25,14 @@
     "Managed-job resource redaction is defense in depth, not a guarantee against transformed or partial secret output. Use capture_output=discard for steps that may echo credentials.",
     "Do not use shell encoding, renaming, or alternate tools to bypass host or platform safety policy.",
     "run_process avoids shell parsing but is not an OS sandbox. exec_command is exposed only in shell mode and has the local user's authority.",
-    "For commands that may produce substantial output, prefer start_process/read_process or use the output_session_id returned by a truncated run_process, run_local_command, or exec_command result. Read output in bounded pages instead of repeatedly requesting a larger one-shot response.",
+    "Remote foreground run_process, run_local_command, exec_command, browser, and application calls are limited to 85 seconds and reject larger requested timeouts before local side effects begin. Keep mutations separate from validation. For longer work, use start_process/read_process or start_job/read_job. If the host omits those tools, start a non-interactive command that writes bounded output and an exit-status file under ignored project-local state, then poll those files with short calls.",
     "Per-tool success, failure, cancellation, and timing events are debug-only; default logs contain lifecycle and infrastructure events, not a tool-call transcript.",
     "Inspect before editing, prefer read_file line ranges, edit_file, or apply_patch over whole-file replacement, and report commands that were run."
+  ],
+  "modernProtocolVersions": [
+    "2026-07-28"
+  ],
+  "legacyProtocolVersions": [
+    "2025-11-25"
   ]
 }

package/src/shared/tool-argument-validation.d.mts

@@ -0,0 +1,17 @@
+export const JSON_SCHEMA_2020_12: "https://json-schema.org/draft/2020-12/schema";
+export type ToolValidationIssue = Readonly<{ instancePath: string; keyword: string; message: string }>;
+export class ToolSchemaContractError extends Error {}
+export class ToolArgumentValidationError extends Error {
+  code: "invalid_request";
+  retryable: false;
+  details: Readonly<{ tool: string; validation_issues: readonly ToolValidationIssue[] }>;
+}
+export function compileToolArgumentValidators(
+  tools: readonly Array<{ name: string; inputSchema?: unknown }>,
+  options?: { maximumDepth?: number; maximumNodes?: number; maximumIssues?: number; maximumPatternLength?: number; maximumValidationSteps?: number },
+): Readonly<{
+  names: readonly string[];
+  has(tool: unknown): boolean;
+  validate(tool: unknown, value: unknown): Readonly<{ known: boolean; valid: boolean; issues: readonly ToolValidationIssue[] }>;
+  assert<T>(tool: unknown, value: T): T;
+}>;