machine-bridge-mcp 0.2.5 → 0.4.0

package/tsconfig.json

@@ -10,10 +10,12 @@
     "strict": true,
     "noEmit": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
   },
   "include": [
     "src/worker/**/*.ts",
-    "src/worker/**/*.d.ts"
+    "src/worker/**/*.d.ts",
+    "src/shared/**/*.json"
   ]
 }

package/wrangler.jsonc

@@ -21,10 +21,10 @@
   ],
   "observability": {
     "enabled": true,
-    "head_sampling_rate": 1
+    "head_sampling_rate": 0.1
   },
   "vars": {
-    "MBM_WORKER_MAX_BODY_BYTES": "33554432",
+    "MBM_WORKER_MAX_BODY_BYTES": "8388608",
     "MBM_ALLOWED_ORIGINS": ""
   }
 }

package/src/local/api-server.mjs

@@ -1,368 +0,0 @@
-import http from "node:http";
-import { createHash, randomUUID } from "node:crypto";
-import { createLogger } from "./log.mjs";
-
-export const DEFAULT_API_HOST = "127.0.0.1";
-export const DEFAULT_API_PORT = 8765;
-export const DEFAULT_API_MODEL = "chatgpt-mcp";
-export const DEFAULT_API_MAX_BODY_BYTES = 32 * 1024 * 1024;
-export const DEFAULT_SAMPLING_TIMEOUT_MS = 180_000;
-
-const CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
-
-export function parseApiPort(value, fallback = DEFAULT_API_PORT) {
-  if (value === undefined || value === null || value === true || value === "") return fallback;
-  const port = Number(value);
-  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid API port: ${value}`);
-  return port;
-}
-
-export function normalizeApiHost(value, fallback = DEFAULT_API_HOST) {
-  if (value === undefined || value === null || value === true || value === "") return fallback;
-  const host = String(value).trim();
-  if (!host) return fallback;
-  if (/[\\/\s]/.test(host)) throw new Error(`Invalid API host: ${value}`);
-  return host;
-}
-
-export async function startLocalApiServer(options = {}) {
-  const logger = options.logger || createLogger({ component: "api", quiet: options.quiet });
-  const host = normalizeApiHost(options.host);
-  const port = parseApiPort(options.port);
-  const apiKey = String(options.apiKey || "");
-  const model = String(options.model || DEFAULT_API_MODEL);
-  const workerUrl = String(options.workerUrl || "").replace(/\/+$/, "");
-  const daemonSecret = String(options.daemonSecret || "");
-  const maxBodyBytes = Number(options.maxBodyBytes || DEFAULT_API_MAX_BODY_BYTES);
-  const samplingTimeoutMs = Number(options.samplingTimeoutMs || DEFAULT_SAMPLING_TIMEOUT_MS);
-
-  if (!apiKey) throw new Error("Local API key is missing");
-
-  const server = http.createServer((req, res) => {
-    void handleRequest(req, res, { logger, apiKey, model, workerUrl, daemonSecret, maxBodyBytes, samplingTimeoutMs });
-  });
-
-  server.keepAliveTimeout = 65_000;
-  server.headersTimeout = 70_000;
-  server.requestTimeout = 0;
-
-  await new Promise((resolve, reject) => {
-    const onError = error => {
-      server.off("listening", onListening);
-      reject(withPortHint(error, port));
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      resolve();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen({ host, port });
-  });
-
-  const address = server.address();
-  const actualPort = typeof address === "object" && address ? address.port : port;
-  const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-  const baseUrl = `http://${urlHost}:${actualPort}/v1`;
-  logger.success("local OpenAI-compatible API started", { baseUrl, model, backend: "chatgpt-mcp", mcpBridgeConfigured: Boolean(workerUrl && daemonSecret) });
-
-  return {
-    server,
-    host,
-    port: actualPort,
-    baseUrl,
-    url: `http://${urlHost}:${actualPort}`,
-    apiKey,
-    model,
-    close() {
-      return new Promise(resolve => server.close(() => resolve()));
-    },
-  };
-}
-
-async function handleRequest(req, res, context) {
-  const requestId = randomUUID().slice(0, 8);
-  const started = Date.now();
-  const url = new URL(req.url || "/", "http://127.0.0.1");
-  setCorsHeaders(res);
-
-  try {
-    if (req.method === "OPTIONS") return sendEmpty(res, 204);
-    if (req.method === "GET" && url.pathname === "/health") {
-      return sendJson(res, 200, {
-        ok: true,
-        service: "machine-bridge-mcp-local-api",
-        backend: "chatgpt-mcp",
-        api_key_sha256: sha256String(context.apiKey),
-        mcp_bridge_configured: Boolean(context.workerUrl && context.daemonSecret),
-        model: context.model,
-      });
-    }
-
-    if (!isAuthorized(req, context.apiKey)) return sendOpenAiError(res, 401, "invalid_api_key", "Missing or invalid local API key.");
-
-    if (req.method === "GET" && url.pathname === "/v1/models") {
-      context.logger.info("request completed", { requestId, method: req.method, path: url.pathname, status: 200, durationMs: Date.now() - started });
-      return sendJson(res, 200, modelsPayload(context));
-    }
-
-    if (req.method === "POST" && ["/v1/responses", "/v1/completions", "/v1/embeddings"].includes(url.pathname)) {
-      return sendOpenAiError(res, 501, "unsupported_endpoint", "Only /v1/chat/completions is available through the ChatGPT MCP-backed local API. Embeddings, legacy completions, and Responses API are not exposed by MCP sampling.");
-    }
-
-    if (req.method === "POST" && url.pathname === CHAT_COMPLETIONS_PATH) {
-      if (!context.workerUrl || !context.daemonSecret) {
-        return sendOpenAiError(res, 503, "mcp_bridge_not_configured", "Local API is not connected to a Remote MCP bridge yet. Run `machine-mcp` normally so the Worker URL and MCP daemon secret exist, then reconnect ChatGPT to the printed MCP Server URL.");
-      }
-      const payload = await readJsonBody(req, context.maxBodyBytes);
-      const { params: samplingRequest, modelHint } = samplingRequestFromOpenAiChat(payload, context.model);
-      context.logger.info("MCP sampling request started", { requestId, path: url.pathname, modelHint: modelHint || null });
-      const result = await requestMcpSampling(context, samplingRequest);
-      const text = extractSamplingText(result);
-      const model = String(result?.model || modelHint || context.model);
-      const finishReason = finishReasonFromSampling(result);
-      if (payload.stream === true) sendChatCompletionStream(res, { text, model, finishReason });
-      else sendJson(res, 200, chatCompletionPayload({ text, model, finishReason }));
-      context.logger.info("MCP sampling request completed", { requestId, path: url.pathname, status: res.statusCode, durationMs: Date.now() - started });
-      return;
-    }
-
-    return sendOpenAiError(res, 404, "not_found", `Unknown local API endpoint: ${url.pathname}`);
-  } catch (error) {
-    context.logger.error("request failed", safeErrorLogFields(error, { requestId, path: url.pathname, durationMs: Date.now() - started }));
-    if (!res.headersSent) {
-      if (error?.code === "BODY_TOO_LARGE") return sendOpenAiError(res, 413, "request_too_large", error.message);
-      if (error instanceof ApiError) return sendOpenAiError(res, error.status, error.code, error.message);
-      return sendOpenAiError(res, 502, "mcp_sampling_error", error.message || "Local API request failed.");
-    }
-    res.destroy(error);
-  }
-}
-
-function samplingRequestFromOpenAiChat(payload, advertisedModel) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new ApiError(400, "invalid_request_error", "Request body must be a JSON object.");
-  if (!Array.isArray(payload.messages)) throw new ApiError(400, "invalid_request_error", "messages must be an array.");
-  const requestedModel = typeof payload.model === "string" && payload.model.trim() ? payload.model.trim() : "";
-  const modelHint = requestedModel && requestedModel !== advertisedModel ? requestedModel : "";
-  const messages = [];
-  const systemParts = [];
-  for (const message of payload.messages) {
-    const role = normalizeRole(message?.role);
-    const text = contentToText(message?.content);
-    if (!text) continue;
-    if (role === "system") systemParts.push(text);
-    else messages.push({ role, content: { type: "text", text } });
-  }
-  if (!messages.length) throw new ApiError(400, "invalid_request_error", "No user/assistant message content was provided.");
-  const params = {
-    messages,
-    systemPrompt: systemParts.join("\n\n") || undefined,
-    maxTokens: clampInt(payload.max_tokens ?? payload.max_completion_tokens ?? payload.max_output_tokens, 1024, 1, 128000),
-    stopSequences: Array.isArray(payload.stop) ? payload.stop.map(String) : typeof payload.stop === "string" ? [payload.stop] : undefined,
-  };
-  if (typeof payload.temperature === "number" && Number.isFinite(payload.temperature)) params.temperature = payload.temperature;
-  if (modelHint) params.modelPreferences = { hints: [{ name: modelHint }] };
-  return { params: removeUndefined(params), modelHint };
-}
-
-async function requestMcpSampling(context, samplingRequest) {
-  let response;
-  try {
-    response = await fetch(`${context.workerUrl}/api/mcp/sampling`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "X-Bridge-Token": context.daemonSecret,
-      },
-      body: JSON.stringify({ ...samplingRequest, timeout_ms: context.samplingTimeoutMs }),
-      signal: AbortSignal.timeout(context.samplingTimeoutMs + 5_000),
-    });
-  } catch (error) {
-    if (error?.name === "TimeoutError" || error?.name === "AbortError") {
-      throw new ApiError(504, "mcp_sampling_timeout", "Timed out waiting for the Worker and connected MCP client to complete sampling/createMessage.");
-    }
-    throw error;
-  }
-  const body = await response.json().catch(() => null);
-  if (!response.ok) {
-    throw new ApiError(response.status, String(body?.error || "mcp_sampling_error"), String(body?.message || `MCP sampling request failed with HTTP ${response.status}`));
-  }
-  return body?.result ?? body;
-}
-
-function extractSamplingText(result) {
-  const content = result?.content;
-  if (typeof content === "string") return content;
-  if (content?.type === "text" && typeof content.text === "string") return content.text;
-  if (Array.isArray(content)) return content.map(item => item?.type === "text" ? item.text : "").filter(Boolean).join("\n");
-  if (typeof result?.text === "string") return result.text;
-  return JSON.stringify(result ?? {});
-}
-
-function finishReasonFromSampling(result) {
-  const reason = String(result?.stopReason || "").toLowerCase();
-  if (reason === "maxtokens" || reason === "max_tokens" || reason === "length") return "length";
-  if (reason === "tooluse" || reason === "tool_use") return "tool_calls";
-  return "stop";
-}
-
-function chatCompletionPayload({ text, model, finishReason }) {
-  return {
-    id: `chatcmpl-${randomUUID()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1000),
-    model,
-    choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: finishReason }],
-    usage: null,
-  };
-}
-
-function sendChatCompletionStream(res, { text, model, finishReason }) {
-  res.statusCode = 200;
-  res.setHeader("content-type", "text/event-stream; charset=utf-8");
-  res.setHeader("cache-control", "no-cache");
-  const id = `chatcmpl-${randomUUID()}`;
-  const created = Math.floor(Date.now() / 1000);
-  const first = { id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta: { role: "assistant", content: text }, finish_reason: null }] };
-  const done = { id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta: {}, finish_reason: finishReason }] };
-  res.write(`data: ${JSON.stringify(first)}\n\n`);
-  res.write(`data: ${JSON.stringify(done)}\n\n`);
-  res.write("data: [DONE]\n\n");
-  res.end();
-}
-
-function modelsPayload(context) {
-  return {
-    object: "list",
-    data: [{ id: context.model, object: "model", created: 0, owned_by: "chatgpt-mcp" }],
-  };
-}
-
-function normalizeRole(role) {
-  if (role === "assistant") return "assistant";
-  if (role === "system" || role === "developer") return "system";
-  return "user";
-}
-
-function contentToText(content) {
-  if (content === undefined || content === null) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) return content.map(contentPartToText).filter(Boolean).join("\n");
-  return contentPartToText(content);
-}
-
-function contentPartToText(content) {
-  if (content === undefined || content === null) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) return content.map(contentPartToText).filter(Boolean).join("\n");
-  if (typeof content === "object") {
-    if ((content.type === "text" || content.type === "input_text") && typeof content.text === "string") return content.text;
-    if (typeof content.text === "string") return content.text;
-    if (typeof content.content === "string") return content.content;
-    if (content.type === "text" && typeof content.value === "string") return content.value;
-    if (typeof content.type === "string" && content.type) {
-      throw new ApiError(400, "unsupported_content", `Only text message content is supported by this MCP-backed local chat API; unsupported content part: ${content.type}.`);
-    }
-    return "";
-  }
-  return String(content);
-}
-
-function removeUndefined(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
-}
-
-function readJsonBody(req, maxBytes) {
-  return readBody(req, maxBytes).then(buffer => {
-    try {
-      const text = buffer.toString("utf8");
-      return text.trim() ? JSON.parse(text) : {};
-    } catch {
-      throw new ApiError(400, "invalid_json", "Request body is not valid JSON.");
-    }
-  });
-}
-
-function readBody(req, maxBytes) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    let total = 0;
-    req.on("data", chunk => {
-      total += chunk.length;
-      if (total > maxBytes) {
-        const error = new Error(`Request body exceeds ${maxBytes} bytes`);
-        error.code = "BODY_TOO_LARGE";
-        req.destroy(error);
-        reject(error);
-        return;
-      }
-      chunks.push(chunk);
-    });
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
-  });
-}
-
-function sha256String(value) {
-  return createHash("sha256").update(String(value)).digest("hex");
-}
-
-function isAuthorized(req, expectedKey) {
-  const auth = String(req.headers.authorization || "");
-  if (auth.startsWith("Bearer ") && auth.slice(7) === expectedKey) return true;
-  const apiKey = req.headers["x-api-key"];
-  return typeof apiKey === "string" && apiKey === expectedKey;
-}
-
-function sendOpenAiError(res, status, code, message) {
-  return sendJson(res, status, { error: { message, type: "invalid_request_error", param: null, code } });
-}
-
-function sendJson(res, status, payload) {
-  if (!res.headersSent) {
-    res.statusCode = status;
-    res.setHeader("content-type", "application/json; charset=utf-8");
-  }
-  res.end(`${JSON.stringify(payload)}\n`);
-}
-
-function sendEmpty(res, status) {
-  res.statusCode = status;
-  res.end();
-}
-
-function setCorsHeaders(res) {
-  res.setHeader("access-control-allow-origin", "*");
-  res.setHeader("access-control-allow-methods", "GET,POST,OPTIONS");
-  res.setHeader("access-control-allow-headers", "authorization,content-type,x-api-key,openai-beta,openai-organization,openai-project");
-}
-
-function safeErrorLogFields(error, fields) {
-  if (error instanceof ApiError) return { ...fields, status: error.status, code: error.code };
-  if (error?.code === "BODY_TOO_LARGE") return { ...fields, status: 413, code: "request_too_large" };
-  return { ...fields, error: error?.name || "Error" };
-}
-
-function withPortHint(error, port) {
-  if (error?.code === "EADDRINUSE") {
-    error.message = `Local API port ${port} is already in use. Re-run with \`machine-mcp --api-port <free_port>\` or \`machine-mcp api --api-port <free_port>\`.`;
-  }
-  if (error?.code === "EACCES") {
-    error.message = `Local API port ${port} is not permitted. Re-run with \`machine-mcp --api-port <free_port>\` or \`machine-mcp api --api-port <free_port>\`.`;
-  }
-  return error;
-}
-
-function clampInt(value, fallback, min, max) {
-  const number = Number(value);
-  if (!Number.isFinite(number)) return fallback;
-  return Math.min(Math.max(Math.floor(number), min), max);
-}
-
-class ApiError extends Error {
-  constructor(status, code, message) {
-    super(message);
-    this.status = status;
-    this.code = code;
-  }
-}

package/src/local/self-test.mjs

@@ -1,256 +0,0 @@
-import { createHash } from "node:crypto";
-import http from "node:http";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { daemonSelfTest } from "./daemon.mjs";
-import { startLocalApiServer } from "./api-server.mjs";
-import { createLogger, redactSecret } from "./log.mjs";
-import { acquireDaemonLock, ensureLocalApiKey, ensureWorkerSecrets, loadState, previewSecret, redactState, saveState, selectedWorkspace, setSelectedWorkspace } from "./state.mjs";
-
-await daemonSelfTest();
-await stateSelfTest();
-await workerSourceSelfTest();
-await apiSelfTest();
-console.log("local daemon/state/api self-test ok");
-
-async function stateSelfTest() {
-  const stateRoot = await mkdtemp(join(tmpdir(), "mbm-state-test-"));
-  const workspace = await mkdtemp(join(tmpdir(), "mbm-state-workspace-"));
-  try {
-    setSelectedWorkspace(workspace, stateRoot);
-    if (selectedWorkspace(stateRoot) !== workspace) throw new Error("selected workspace was not persisted");
-    const state = loadState(workspace, { stateDir: stateRoot });
-    ensureWorkerSecrets(state, { rotateSecrets: true });
-    ensureLocalApiKey(state, { rotateApiKey: true });
-    const lock = acquireDaemonLock(state);
-    if (!lock.acquired) throw new Error("first daemon lock acquisition failed");
-    try {
-      const duplicate = acquireDaemonLock(state);
-      if (duplicate.acquired) throw new Error("duplicate daemon lock acquisition should fail");
-      if (duplicate.owner?.pid !== process.pid) throw new Error("duplicate daemon lock owner was not reported");
-    } finally {
-      lock.release();
-    }
-    const relock = acquireDaemonLock(state);
-    if (!relock.acquired) throw new Error("daemon lock was not released");
-    relock.release();
-
-    const redacted = redactState(state);
-    if (redacted.worker.oauthPassword === state.worker.oauthPassword) throw new Error("oauthPassword was not redacted");
-    if (redacted.worker.daemonSecret === state.worker.daemonSecret) throw new Error("daemonSecret was not redacted");
-    if (redacted.worker.oauthTokenVersion === state.worker.oauthTokenVersion) throw new Error("oauthTokenVersion was not redacted");
-    if (redacted.localApi.apiKey === state.localApi.apiKey) throw new Error("local API key was not redacted");
-    if (!previewSecret(state.worker.oauthPassword).includes("...")) throw new Error("previewSecret did not preview long secret");
-    if (!redactSecret(state.localApi.apiKey).includes("...")) throw new Error("redactSecret did not preview long secret");
-
-    state.localApi.upstreamUrl = "https://api.example.test/v1";
-    state.localApi.upstreamKey = "old-upstream-key";
-    state.localApi.upstreamModel = "old-upstream-model";
-    saveState(state);
-    const migrated = loadState(workspace, { stateDir: stateRoot });
-    if ("upstreamUrl" in migrated.localApi || "upstreamKey" in migrated.localApi || "upstreamModel" in migrated.localApi) {
-      throw new Error("legacy upstream local API state was not migrated away");
-    }
-  } finally {
-    await rm(stateRoot, { recursive: true, force: true }).catch(() => {});
-    await rm(workspace, { recursive: true, force: true }).catch(() => {});
-  }
-}
-
-async function workerSourceSelfTest() {
-  const source = await readFile(new URL("../worker/index.ts", import.meta.url), "utf8");
-  const unawaitedAsyncRoutes = [
-    "return this.registerClient(request);",
-    "return this.authorizeSubmit(request, base);",
-    "return this.exchangeToken(request, base);",
-    "return this.acceptDaemonWebSocket(request);",
-    "return this.handleMcp(request, base);",
-    "return this.handleSamplingApi(request);",
-  ].filter((snippet) => source.includes(snippet));
-  if (unawaitedAsyncRoutes.length) {
-    throw new Error(`Worker async routes must be awaited so HttpError is caught: ${unawaitedAsyncRoutes.join(", ")}`);
-  }
-}
-
-
-async function apiSelfTest() {
-  const logger = createLogger({ quiet: true, component: "api-test" });
-  const api = await startLocalApiServer({
-    host: "127.0.0.1",
-    port: 0,
-    apiKey: "local-test-key",
-    model: "chatgpt-mcp",
-    logger,
-  });
-  const base = `http://${api.host}:${api.port}`;
-  try {
-    if (api.apiKey !== "local-test-key") throw new Error("local API server did not expose runtime API key for CLI printing");
-    const health = await fetch(`${base}/health`);
-    if (health.status !== 200) throw new Error(`health returned ${health.status}`);
-    const healthPayload = await health.json();
-    const expectedHash = createHash("sha256").update("local-test-key").digest("hex");
-    if (healthPayload.api_key_sha256 !== expectedHash) throw new Error("health did not expose expected API key hash");
-    if (healthPayload.backend !== "chatgpt-mcp") throw new Error("health did not report MCP-backed backend");
-    if (healthPayload.mcp_bridge_configured !== false) throw new Error("health should report missing MCP bridge");
-    const unauth = await fetch(`${base}/v1/models`);
-    if (unauth.status !== 401) throw new Error(`unauthorized models returned ${unauth.status}`);
-    const models = await fetch(`${base}/v1/models`, { headers: { authorization: "Bearer local-test-key" } });
-    if (models.status !== 200) throw new Error(`authorized models returned ${models.status}`);
-    const payload = await models.json();
-    if (payload?.data?.length !== 1 || payload.data[0].id !== "chatgpt-mcp") throw new Error("model payload should expose local MCP model");
-    const chat = await fetch(`${base}/v1/chat/completions`, {
-      method: "POST",
-      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-      body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
-    });
-    if (chat.status !== 503) throw new Error(`missing MCP bridge should return 503, got ${chat.status}`);
-    const chatPayload = await chat.json();
-    if (!/Remote MCP bridge/.test(chatPayload?.error?.message || "")) throw new Error("missing bridge error did not clarify MCP bridge requirement");
-
-    const unsupported = await fetch(`${base}/v1/responses`, {
-      method: "POST",
-      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-      body: JSON.stringify({ input: "hello" }),
-    });
-    if (unsupported.status !== 501) throw new Error(`unsupported Responses endpoint returned ${unsupported.status}`);
-    const unsupportedPayload = await unsupported.json();
-    if (unsupportedPayload?.error?.code !== "unsupported_endpoint") throw new Error("unsupported endpoint did not return explicit error code");
-
-  } finally {
-    await api.close();
-  }
-
-  await mcpSamplingSelfTest(logger);
-  await mcpSamplingErrorSelfTest(logger);
-}
-
-async function mcpSamplingSelfTest(logger) {
-  let captured = null;
-  const expectedErrorLogger = { ...logger, error() {} };
-  const worker = http.createServer((req, res) => {
-    const chunks = [];
-    req.on("data", chunk => chunks.push(chunk));
-    req.on("end", () => {
-      captured = { bridgeToken: req.headers["x-bridge-token"], url: req.url, body: JSON.parse(Buffer.concat(chunks).toString("utf8")) };
-      res.setHeader("content-type", "application/json");
-      res.end(JSON.stringify({ ok: true, result: { role: "assistant", content: { type: "text", text: "hello from ChatGPT MCP" }, model: "chatgpt-client-model", stopReason: "endTurn" } }));
-    });
-  });
-  await new Promise(resolve => worker.listen({ host: "127.0.0.1", port: 0 }, resolve));
-  const workerPort = worker.address().port;
-  const api = await startLocalApiServer({
-    host: "127.0.0.1",
-    port: 0,
-    apiKey: "local-test-key",
-    workerUrl: `http://127.0.0.1:${workerPort}`,
-    daemonSecret: "daemon-test-secret",
-    model: "chatgpt-mcp",
-    logger: expectedErrorLogger,
-  });
-  try {
-    const models = await fetch(`http://${api.host}:${api.port}/v1/models`, { headers: { authorization: "Bearer local-test-key" } });
-    if (models.status !== 200) throw new Error(`configured models returned ${models.status}`);
-    const modelsPayload = await models.json();
-    if (modelsPayload?.data?.length !== 1 || modelsPayload.data[0].id !== "chatgpt-mcp") throw new Error("model payload did not expose local MCP model");
-
-    const image = await fetch(`http://${api.host}:${api.port}/v1/chat/completions`, {
-      method: "POST",
-      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-      body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: [{ type: "image_url", image_url: { url: "https://example.test/image.png" } }] }] }),
-    });
-    if (image.status !== 400) throw new Error(`unsupported non-text content returned ${image.status}`);
-    const imagePayload = await image.json();
-    if (imagePayload?.error?.code !== "unsupported_content") throw new Error("unsupported non-text content did not return explicit error code");
-
-    const response = await fetch(`http://${api.host}:${api.port}/v1/chat/completions`, {
-      method: "POST",
-      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-      body: JSON.stringify({
-        model: "gpt-5-hint",
-        messages: [
-          { role: "system", content: "Be concise." },
-          { role: "developer", content: "Use plain text." },
-          { role: "user", content: [{ type: "text", text: "Say hello" }] },
-        ],
-        max_completion_tokens: 77,
-      }),
-    });
-    if (response.status !== 200) throw new Error(`MCP sampling rewrite returned ${response.status}`);
-    if (captured?.url !== "/api/mcp/sampling") throw new Error("sampling request did not target Worker sampling endpoint");
-    if (captured?.bridgeToken !== "daemon-test-secret") throw new Error("bridge token was not set");
-    if (captured?.body?.messages?.[0]?.content?.text !== "Say hello") throw new Error("chat message was not converted to MCP sampling message");
-    if (captured?.body?.systemPrompt !== "Be concise.\n\nUse plain text.") throw new Error("system/developer prompt was not forwarded");
-    if (captured?.body?.maxTokens !== 77) throw new Error("max_completion_tokens was not converted to maxTokens");
-    if (captured?.body?.modelPreferences?.hints?.[0]?.name !== "gpt-5-hint") throw new Error("model hint was not forwarded");
-    const payload = await response.json();
-    if (payload?.choices?.[0]?.message?.content !== "hello from ChatGPT MCP") throw new Error("MCP sampling result was not wrapped as chat completion");
-    if (payload?.model !== "chatgpt-client-model") throw new Error("MCP sampling result model was not preserved");
-  } finally {
-    await api.close();
-    await new Promise(resolve => worker.close(resolve));
-  }
-}
-
-async function mcpSamplingErrorSelfTest(logger) {
-  await withMockWorkerError(
-    logger,
-    409,
-    { error: "mcp_client_stream_missing", message: "No MCP client has an open server-to-client stream for sampling/createMessage." },
-    async ({ base }) => {
-      const response = await fetch(`${base}/v1/chat/completions`, {
-        method: "POST",
-        headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-        body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
-      });
-      if (response.status !== 409) throw new Error(`missing MCP stream should return 409, got ${response.status}`);
-      const payload = await response.json();
-      if (payload?.error?.code !== "mcp_client_stream_missing") throw new Error("missing MCP stream error code was not preserved");
-      if (!/MCP client|server-to-client stream/.test(payload?.error?.message || "")) throw new Error("missing MCP stream error message was not explicit");
-    }
-  );
-
-  await withMockWorkerError(
-    logger,
-    501,
-    { error: "mcp_sampling_not_supported", message: "A connected MCP client did not advertise the MCP sampling capability." },
-    async ({ base }) => {
-      const response = await fetch(`${base}/v1/chat/completions`, {
-        method: "POST",
-        headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-        body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
-      });
-      if (response.status !== 501) throw new Error(`missing sampling capability should return 501, got ${response.status}`);
-      const payload = await response.json();
-      if (payload?.error?.code !== "mcp_sampling_not_supported") throw new Error("missing sampling capability error code was not preserved");
-      if (!/sampling capability/.test(payload?.error?.message || "")) throw new Error("missing sampling capability message was not explicit");
-    }
-  );
-}
-
-async function withMockWorkerError(logger, status, payload, callback) {
-  const expectedErrorLogger = { ...logger, error() {} };
-  const worker = http.createServer((req, res) => {
-    req.resume();
-    res.statusCode = status;
-    res.setHeader("content-type", "application/json");
-    res.end(JSON.stringify(payload));
-  });
-  await new Promise(resolve => worker.listen({ host: "127.0.0.1", port: 0 }, resolve));
-  const workerPort = worker.address().port;
-  const api = await startLocalApiServer({
-    host: "127.0.0.1",
-    port: 0,
-    apiKey: "local-test-key",
-    workerUrl: `http://127.0.0.1:${workerPort}`,
-    daemonSecret: "daemon-test-secret",
-    model: "chatgpt-mcp",
-    logger: expectedErrorLogger,
-  });
-  try {
-    await callback({ base: `http://${api.host}:${api.port}` });
-  } finally {
-    await api.close();
-    await new Promise(resolve => worker.close(resolve));
-  }
-}