@btraut/browser-bridge 0.11.0 → 0.12.0

package/dist/api.js

@@ -39,55 +39,8 @@ module.exports = __toCommonJS(api_exports);
 var import_http = require("http");
 var import_express2 = __toESM(require("express"));
 
-// packages/shared/src/errors.ts
-var import_zod = require("zod");
-var ErrorCodeSchema = import_zod.z.enum([
-  "UNKNOWN",
-  "INVALID_ARGUMENT",
-  "NOT_FOUND",
-  "ALREADY_EXISTS",
-  "FAILED_PRECONDITION",
-  "UNAUTHORIZED",
-  "FORBIDDEN",
-  "PERMISSION_REQUIRED",
-  "PERMISSION_DENIED",
-  "PERMISSION_PROMPT_TIMEOUT",
-  "CONFLICT",
-  "TIMEOUT",
-  "CANCELLED",
-  "UNAVAILABLE",
-  "RATE_LIMITED",
-  "NOT_IMPLEMENTED",
-  "INTERNAL",
-  "SESSION_NOT_FOUND",
-  "SESSION_CLOSED",
-  "SESSION_BROKEN",
-  "DRIVE_UNAVAILABLE",
-  "INSPECT_UNAVAILABLE",
-  "EXTENSION_DISCONNECTED",
-  "DEBUGGER_IN_USE",
-  "ATTACH_DENIED",
-  "TAB_NOT_FOUND",
-  "NOT_SUPPORTED",
-  "LOCATOR_NOT_FOUND",
-  "NAVIGATION_FAILED",
-  "EVALUATION_FAILED",
-  "ARTIFACT_IO_ERROR"
-]);
-var ErrorInfoSchema = import_zod.z.object({
-  code: ErrorCodeSchema,
-  message: import_zod.z.string(),
-  retryable: import_zod.z.boolean(),
-  details: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
-});
-var ErrorEnvelopeSchema = import_zod.z.object({
-  ok: import_zod.z.literal(false),
-  error: ErrorInfoSchema
-});
-var successEnvelopeSchema = (result) => import_zod.z.object({
-  ok: import_zod.z.literal(true),
-  result
-});
+// packages/shared/src/core-readiness.ts
+var import_promises = require("node:timers/promises");
 
 // packages/shared/src/logging.ts
 var import_node_fs2 = require("node:fs");
@@ -638,6 +591,248 @@ var createJsonlLogger = (options) => {
   return buildLogger(state, options.bindings ?? {});
 };
 
+// packages/shared/src/core-readiness.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_HEALTH_RETRY_MS = 250;
+var DEFAULT_HEALTH_ATTEMPTS = 20;
+var DEFAULT_HEALTH_TIMEOUT_MS = 2e3;
+var DEFAULT_HEALTH_BUDGET_MS = 15e3;
+var resolveTimeoutMs = (timeoutMs) => {
+  const candidate = timeoutMs ?? (process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS, 10) : process.env.BROWSER_VISION_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_VISION_CORE_TIMEOUT_MS, 10) : void 0);
+  if (candidate === void 0 || candidate === null) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  const parsed = typeof candidate === "number" ? candidate : Number(candidate);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid timeoutMs: ${String(candidate)}`);
+  }
+  return Math.floor(parsed);
+};
+var resolvePositiveInteger = (value, fallback) => {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`Invalid positive integer value: ${String(value)}`);
+  }
+  return Math.floor(value);
+};
+var hasExplicitRuntimeInput = (options) => options.host !== void 0 || options.port !== void 0 || process.env.BROWSER_BRIDGE_CORE_HOST !== void 0 || process.env.BROWSER_VISION_CORE_HOST !== void 0 || process.env.BROWSER_BRIDGE_CORE_PORT !== void 0 || process.env.BROWSER_VISION_CORE_PORT !== void 0;
+var createCoreReadinessController = (options = {}) => {
+  const logger = options.logger ?? createJsonlLogger({
+    stream: "cli",
+    cwd: options.cwd
+  }).child({ scope: "core-readiness" });
+  const logPrefix = options.logPrefix ?? "core";
+  const timeoutMs = resolveTimeoutMs(options.timeoutMs);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const ensureDaemon = options.ensureDaemon ?? true;
+  const healthRetryMs = resolvePositiveInteger(
+    options.healthRetryMs,
+    DEFAULT_HEALTH_RETRY_MS
+  );
+  const healthAttempts = resolvePositiveInteger(
+    options.healthAttempts,
+    DEFAULT_HEALTH_ATTEMPTS
+  );
+  const healthTimeoutMs = resolvePositiveInteger(
+    options.healthTimeoutMs,
+    Math.min(timeoutMs, DEFAULT_HEALTH_TIMEOUT_MS)
+  );
+  const healthBudgetMs = resolvePositiveInteger(
+    options.healthBudgetMs,
+    DEFAULT_HEALTH_BUDGET_MS
+  );
+  let runtime = resolveCoreRuntime({
+    host: options.host,
+    port: options.port,
+    cwd: options.cwd,
+    strictEnvPort: options.strictEnvPort ?? true
+  });
+  let baseUrl = `http://${runtime.host}:${runtime.port}`;
+  const allowRuntimeRefresh = !hasExplicitRuntimeInput(options);
+  const refreshRuntime = () => {
+    if (!allowRuntimeRefresh) {
+      return;
+    }
+    runtime = resolveCoreRuntime({
+      cwd: options.cwd,
+      strictEnvPort: options.strictEnvPort ?? true
+    });
+    baseUrl = `http://${runtime.host}:${runtime.port}`;
+  };
+  const checkHealth = async () => {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
+      try {
+        let response;
+        try {
+          response = await fetchImpl(`${baseUrl}/health`, {
+            method: "GET",
+            signal: controller.signal
+          });
+        } catch (error) {
+          if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
+            logger.warn(`${logPrefix}.health.timeout`, {
+              base_url: baseUrl,
+              timeout_ms: healthTimeoutMs
+            });
+            return false;
+          }
+          logger.warn(`${logPrefix}.health.fetch_failed`, {
+            base_url: baseUrl,
+            error
+          });
+          throw error;
+        }
+        if (!response.ok) {
+          logger.warn(`${logPrefix}.health.non_ok`, {
+            base_url: baseUrl,
+            status: response.status
+          });
+          return false;
+        }
+        const data = await response.json().catch(() => null);
+        const ok = Boolean(data?.ok);
+        if (!ok) {
+          logger.warn(`${logPrefix}.health.not_ready`, {
+            base_url: baseUrl
+          });
+        }
+        return ok;
+      } finally {
+        clearTimeout(timeout);
+      }
+    } catch (error) {
+      logger.warn(`${logPrefix}.health.error`, {
+        base_url: baseUrl,
+        error
+      });
+      return false;
+    }
+  };
+  const ensureCoreRunning = async () => {
+    refreshRuntime();
+    if (await checkHealth()) {
+      logger.debug(`${logPrefix}.ensure_ready.already_running`, {
+        base_url: baseUrl
+      });
+      return;
+    }
+    if (!options.spawnDaemon) {
+      logger.error(`${logPrefix}.ensure_ready.missing_spawn`, {
+        host: runtime.host,
+        port: runtime.port
+      });
+      throw new Error(
+        `Core daemon is not running on ${runtime.host}:${runtime.port} and spawnDaemon is not configured.`
+      );
+    }
+    options.spawnDaemon(runtime);
+    const deadlineAt = Date.now() + healthBudgetMs;
+    for (let attempt = 0; attempt < healthAttempts; attempt += 1) {
+      const remainingBudgetMs = deadlineAt - Date.now();
+      if (remainingBudgetMs <= 0) {
+        break;
+      }
+      await (0, import_promises.setTimeout)(Math.min(healthRetryMs, remainingBudgetMs));
+      refreshRuntime();
+      if (await checkHealth()) {
+        logger.info(`${logPrefix}.ensure_ready.ready`, {
+          base_url: baseUrl,
+          attempts: attempt + 1
+        });
+        return;
+      }
+    }
+    logger.error(`${logPrefix}.ensure_ready.failed`, {
+      host: runtime.host,
+      port: runtime.port,
+      attempts: healthAttempts,
+      health_budget_ms: healthBudgetMs,
+      health_timeout_ms: healthTimeoutMs
+    });
+    throw new Error(
+      `Core daemon failed to start on ${runtime.host}:${runtime.port}.`
+    );
+  };
+  let ensurePromise = null;
+  const ensureReady = async () => {
+    if (!ensureDaemon) {
+      return;
+    }
+    if (!ensurePromise) {
+      ensurePromise = ensureCoreRunning().catch((error) => {
+        ensurePromise = null;
+        throw error;
+      });
+    }
+    await ensurePromise;
+  };
+  return {
+    get baseUrl() {
+      return baseUrl;
+    },
+    get runtime() {
+      return runtime;
+    },
+    refreshRuntime,
+    ensureReady,
+    checkHealth
+  };
+};
+
+// packages/shared/src/errors.ts
+var import_zod = require("zod");
+var ErrorCodeSchema = import_zod.z.enum([
+  "UNKNOWN",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ALREADY_EXISTS",
+  "FAILED_PRECONDITION",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "PERMISSION_REQUIRED",
+  "PERMISSION_DENIED",
+  "PERMISSION_PROMPT_TIMEOUT",
+  "CONFLICT",
+  "TIMEOUT",
+  "CANCELLED",
+  "UNAVAILABLE",
+  "RATE_LIMITED",
+  "NOT_IMPLEMENTED",
+  "INTERNAL",
+  "SESSION_NOT_FOUND",
+  "SESSION_CLOSED",
+  "SESSION_BROKEN",
+  "DRIVE_UNAVAILABLE",
+  "INSPECT_UNAVAILABLE",
+  "EXTENSION_DISCONNECTED",
+  "DEBUGGER_IN_USE",
+  "ATTACH_DENIED",
+  "TAB_NOT_FOUND",
+  "NOT_SUPPORTED",
+  "LOCATOR_NOT_FOUND",
+  "NAVIGATION_FAILED",
+  "EVALUATION_FAILED",
+  "ARTIFACT_IO_ERROR"
+]);
+var ErrorInfoSchema = import_zod.z.object({
+  code: ErrorCodeSchema,
+  message: import_zod.z.string(),
+  retryable: import_zod.z.boolean(),
+  details: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var ErrorEnvelopeSchema = import_zod.z.object({
+  ok: import_zod.z.literal(false),
+  error: ErrorInfoSchema
+});
+var successEnvelopeSchema = (result) => import_zod.z.object({
+  ok: import_zod.z.literal(true),
+  result
+});
+
 // packages/shared/src/schemas.ts
 var import_zod2 = require("zod");
 var LocatorRoleSchema = import_zod2.z.object({
@@ -702,6 +897,39 @@ var DiagnosticCheckSchema = import_zod2.z.object({
   message: import_zod2.z.string().optional(),
   details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
 });
+var DiagnosticsRuntimeEndpointSchema = import_zod2.z.object({
+  host: import_zod2.z.string().optional(),
+  port: import_zod2.z.number().finite().optional(),
+  base_url: import_zod2.z.string().optional(),
+  host_source: import_zod2.z.string().optional(),
+  port_source: import_zod2.z.string().optional(),
+  metadata_path: import_zod2.z.string().optional(),
+  isolated_mode: import_zod2.z.boolean().optional()
+});
+var DiagnosticsRuntimeProcessSchema = import_zod2.z.object({
+  component: import_zod2.z.enum(["cli", "mcp", "core"]).optional(),
+  version: import_zod2.z.string().optional(),
+  pid: import_zod2.z.number().int().positive().optional(),
+  node_version: import_zod2.z.string().optional(),
+  binary_path: import_zod2.z.string().optional(),
+  argv_entry: import_zod2.z.string().optional()
+});
+var DiagnosticsRuntimeCallerSchema = import_zod2.z.object({
+  endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
+  process: DiagnosticsRuntimeProcessSchema.optional()
+});
+var DiagnosticsRuntimeContextSchema = import_zod2.z.object({
+  caller: DiagnosticsRuntimeCallerSchema.optional(),
+  core: import_zod2.z.object({
+    endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
+    process: DiagnosticsRuntimeProcessSchema.optional()
+  }).optional(),
+  extension: import_zod2.z.object({
+    version: import_zod2.z.string().optional(),
+    endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
+    port_source: import_zod2.z.enum(["default", "storage"]).optional()
+  }).optional()
+});
 var DiagnosticReportSchema = import_zod2.z.object({
   ok: import_zod2.z.boolean(),
   session_id: import_zod2.z.string().optional(),
@@ -750,7 +978,8 @@ var DiagnosticReportSchema = import_zod2.z.object({
     loop_detected: import_zod2.z.boolean().optional()
   }).optional(),
   warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
-  notes: import_zod2.z.array(import_zod2.z.string()).optional()
+  notes: import_zod2.z.array(import_zod2.z.string()).optional(),
+  runtime: DiagnosticsRuntimeContextSchema.optional()
 });
 var SessionIdSchema = import_zod2.z.object({
   session_id: import_zod2.z.string().min(1)
@@ -1142,7 +1371,8 @@ var HealthCheckOutputSchema = import_zod2.z.object({
   }).passthrough()
 }).passthrough();
 var DiagnosticsDoctorInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1).optional()
+  session_id: import_zod2.z.string().min(1).optional(),
+  caller: DiagnosticsRuntimeCallerSchema.optional()
 });
 var DiagnosticsDoctorOutputSchema = DiagnosticReportSchema;
 
@@ -1612,14 +1842,14 @@ var InspectError = class extends Error {
 
 // packages/core/src/inspect/service.ts
 var import_crypto3 = require("crypto");
-var import_promises2 = require("node:fs/promises");
+var import_promises3 = require("node:fs/promises");
 var import_node_path4 = __toESM(require("node:path"));
 var import_readability = require("@mozilla/readability");
 var import_jsdom = require("jsdom");
 var import_turndown = __toESM(require("turndown"));
 
 // packages/core/src/artifacts.ts
-var import_promises = require("node:fs/promises");
+var import_promises2 = require("node:fs/promises");
 var import_node_os = __toESM(require("node:os"));
 var import_node_path3 = __toESM(require("node:path"));
 var ARTIFACTS_DIR_NAME = "browser-agent";
@@ -1627,7 +1857,7 @@ var resolveTempRoot = () => process.env.TMPDIR || process.env.TEMP || process.en
 var getArtifactRootDir = (sessionId) => import_node_path3.default.join(resolveTempRoot(), ARTIFACTS_DIR_NAME, sessionId);
 var ensureArtifactRootDir = async (sessionId) => {
   const rootDir = getArtifactRootDir(sessionId);
-  await (0, import_promises.mkdir)(rootDir, { recursive: true });
+  await (0, import_promises2.mkdir)(rootDir, { recursive: true });
   return rootDir;
 };
 
@@ -1681,6 +1911,10 @@ var ExtensionBridge = class {
     return {
       connected: this.connected,
       lastSeenAt: this.lastSeenAt,
+      version: this.version,
+      coreHost: this.coreHost,
+      corePort: this.corePort,
+      corePortSource: this.corePortSource,
       tabs: this.tabs
     };
   }
@@ -1718,7 +1952,7 @@ var ExtensionBridge = class {
       status: "request",
       params
     };
-    const response = await new Promise((resolve2, reject) => {
+    const response = await new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -1731,7 +1965,7 @@ var ExtensionBridge = class {
         );
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         timeout
       });
@@ -1816,6 +2050,10 @@ var ExtensionBridge = class {
     this.stopHeartbeat();
     this.connected = false;
     this.socket = null;
+    this.version = void 0;
+    this.coreHost = void 0;
+    this.corePort = void 0;
+    this.corePortSource = void 0;
     this.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
     this.applyDriveDisconnected();
     for (const [id, pending] of this.pending.entries()) {
@@ -1863,10 +2101,25 @@ var ExtensionBridge = class {
   }
   handleEvent(message) {
     if (message.action === "drive.hello" || message.action === "drive.tab_report") {
-      const tabs = message.params?.tabs;
+      const params = message.params;
+      const tabs = params?.tabs;
       if (Array.isArray(tabs)) {
         this.tabs = tabs;
       }
+      if (message.action === "drive.hello") {
+        if (typeof params?.version === "string") {
+          this.version = params.version;
+        }
+        if (typeof params?.core_host === "string") {
+          this.coreHost = params.core_host;
+        }
+        if (typeof params?.core_port === "number" && Number.isFinite(params.core_port)) {
+          this.corePort = params.core_port;
+        }
+        if (params?.core_port_source === "default" || params?.core_port_source === "storage") {
+          this.corePortSource = params.core_port_source;
+        }
+      }
     }
     if (typeof message.action === "string" && message.action.startsWith("debugger.")) {
       this.emitDebuggerEvent(message);
@@ -3473,7 +3726,7 @@ var InspectService = class {
       const rootDir = await ensureArtifactRootDir(input.sessionId);
       const artifactId = (0, import_crypto3.randomUUID)();
       const filePath = import_node_path4.default.join(rootDir, `har-${artifactId}.json`);
-      await (0, import_promises2.writeFile)(filePath, JSON.stringify(har, null, 2), "utf-8");
+      await (0, import_promises3.writeFile)(filePath, JSON.stringify(har, null, 2), "utf-8");
       const result = {
         artifact_id: artifactId,
         path: filePath,
@@ -3652,7 +3905,7 @@ var InspectService = class {
           rootDir,
           `screenshot-${artifactId}.${extension}`
         );
-        await (0, import_promises2.writeFile)(filePath, Buffer.from(data2, "base64"));
+        await (0, import_promises3.writeFile)(filePath, Buffer.from(data2, "base64"));
         const mime = format === "jpeg" ? "image/jpeg" : `image/${format}`;
         const output = {
           artifact_id: artifactId,
@@ -4045,6 +4298,48 @@ var getErrorAgeMs = (timestamp) => {
   }
   return Math.max(0, Date.now() - parsed);
 };
+var endpointLabel = (endpoint) => {
+  if (!endpoint) {
+    return "unknown";
+  }
+  if (endpoint.baseUrl) {
+    return endpoint.baseUrl;
+  }
+  if (endpoint.host && endpoint.port !== void 0) {
+    return `${endpoint.host}:${endpoint.port}`;
+  }
+  return "unknown";
+};
+var hasEndpoint = (endpoint) => Boolean(
+  endpoint && typeof endpoint.host === "string" && endpoint.host.length > 0 && typeof endpoint.port === "number" && Number.isFinite(endpoint.port)
+);
+var toRuntimeEndpoint = (endpoint) => {
+  if (!endpoint) {
+    return void 0;
+  }
+  return {
+    host: endpoint.host,
+    port: endpoint.port,
+    base_url: endpoint.baseUrl,
+    host_source: endpoint.hostSource,
+    port_source: endpoint.portSource,
+    metadata_path: endpoint.metadataPath,
+    isolated_mode: endpoint.isolatedMode
+  };
+};
+var toRuntimeProcess = (process2) => {
+  if (!process2) {
+    return void 0;
+  }
+  return {
+    component: process2.component,
+    version: process2.version,
+    pid: process2.pid,
+    node_version: process2.nodeVersion,
+    binary_path: process2.binaryPath,
+    argv_entry: process2.argvEntry
+  };
+};
 var buildDiagnosticReport = (sessionId, context = {}) => {
   const extensionConnected = context.extension?.connected ?? false;
   const debuggerAttached = context.debugger?.attached ?? false;
@@ -4072,6 +4367,57 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       }
     }
   ];
+  const coreEndpoint = context.runtime?.core?.endpoint;
+  const callerEndpoint = context.runtime?.caller?.endpoint;
+  const extensionEndpoint = context.runtime?.extension?.endpoint;
+  if (hasEndpoint(coreEndpoint) && hasEndpoint(callerEndpoint)) {
+    const matches = coreEndpoint.host === callerEndpoint.host && coreEndpoint.port === callerEndpoint.port;
+    checks.push({
+      name: "runtime.caller.endpoint_match",
+      ok: matches,
+      message: matches ? `Caller endpoint matches core (${endpointLabel(coreEndpoint)}).` : `Caller endpoint ${endpointLabel(
+        callerEndpoint
+      )} differs from core ${endpointLabel(coreEndpoint)}.`,
+      details: {
+        caller_endpoint: endpointLabel(callerEndpoint),
+        core_endpoint: endpointLabel(coreEndpoint),
+        caller_host_source: callerEndpoint.hostSource,
+        caller_port_source: callerEndpoint.portSource,
+        core_host_source: coreEndpoint.hostSource,
+        core_port_source: coreEndpoint.portSource
+      }
+    });
+  }
+  if (extensionConnected && hasEndpoint(coreEndpoint) && hasEndpoint(extensionEndpoint)) {
+    const matches = coreEndpoint.host === extensionEndpoint.host && coreEndpoint.port === extensionEndpoint.port;
+    checks.push({
+      name: "runtime.extension.endpoint_match",
+      ok: matches,
+      message: matches ? `Extension endpoint matches core (${endpointLabel(coreEndpoint)}).` : `Extension endpoint ${endpointLabel(
+        extensionEndpoint
+      )} differs from core ${endpointLabel(coreEndpoint)}.`,
+      details: {
+        extension_endpoint: endpointLabel(extensionEndpoint),
+        core_endpoint: endpointLabel(coreEndpoint),
+        extension_port_source: context.runtime?.extension?.portSource,
+        core_host_source: coreEndpoint.hostSource,
+        core_port_source: coreEndpoint.portSource
+      }
+    });
+  }
+  const callerVersion = context.runtime?.caller?.process?.version;
+  const extensionVersion = extensionConnected ? context.runtime?.extension?.version : void 0;
+  if (callerVersion && extensionVersion) {
+    checks.push({
+      name: "runtime.extension.version_match_caller",
+      ok: callerVersion === extensionVersion,
+      message: callerVersion === extensionVersion ? `Caller and extension versions match (${callerVersion}).` : `Caller version ${callerVersion} differs from extension version ${extensionVersion}.`,
+      details: {
+        caller_version: callerVersion,
+        extension_version: extensionVersion
+      }
+    });
+  }
   if (context.driveLastError) {
     const ageMs = getErrorAgeMs(context.driveLastError.at);
     const isStale = ageMs !== void 0 && ageMs > STALE_ERROR_THRESHOLD_MS;
@@ -4144,6 +4490,7 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
     } : void 0,
     extension: {
       connected: extensionConnected,
+      version: context.extension?.version,
       last_seen_at: context.extension?.lastSeenAt
     },
     debugger: context.debugger ? {
@@ -4168,7 +4515,22 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       } : {}
     } : void 0,
     ...warnings.length > 0 ? { warnings } : {},
-    notes: ["Diagnostics include runtime status; some checks may be stubbed."]
+    notes: ["Diagnostics include runtime status; some checks may be stubbed."],
+    runtime: context.runtime ? {
+      caller: context.runtime.caller ? {
+        endpoint: toRuntimeEndpoint(context.runtime.caller.endpoint),
+        process: toRuntimeProcess(context.runtime.caller.process)
+      } : void 0,
+      core: context.runtime.core ? {
+        endpoint: toRuntimeEndpoint(context.runtime.core.endpoint),
+        process: toRuntimeProcess(context.runtime.core.process)
+      } : void 0,
+      extension: context.runtime.extension ? {
+        version: context.runtime.extension.version,
+        endpoint: toRuntimeEndpoint(context.runtime.extension.endpoint),
+        port_source: context.runtime.extension.portSource
+      } : void 0
+    } : void 0
   };
   return report;
 };
@@ -4213,30 +4575,69 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
     });
   });
   router.post("/diagnostics/doctor", (req, res) => {
-    let sessionId;
-    if (req.body !== void 0) {
-      if (!isRecord(req.body)) {
-        sendError(res, 400, {
-          code: "INVALID_ARGUMENT",
-          message: "Request body must be an object.",
-          retryable: false
-        });
-        return;
-      }
-      const raw = req.body.session_id;
-      if (raw !== void 0 && (typeof raw !== "string" || raw.length === 0)) {
-        sendError(res, 400, {
-          code: "INVALID_ARGUMENT",
-          message: "session_id must be a non-empty string.",
-          retryable: false,
-          details: { field: "session_id" }
-        });
-        return;
-      }
-      sessionId = raw;
+    const body = req.body ?? {};
+    if (!isRecord(body)) {
+      sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: "Request body must be an object.",
+        retryable: false
+      });
+      return;
     }
+    const parsedDoctorInput = DiagnosticsDoctorInputSchema.safeParse(body);
+    if (!parsedDoctorInput.success) {
+      const issue = parsedDoctorInput.error.issues[0];
+      sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: issue?.message ?? "Invalid diagnostics doctor request.",
+        retryable: false,
+        details: issue?.path.length ? { field: issue.path.map((part) => String(part)).join(".") } : void 0
+      });
+      return;
+    }
+    const sessionId = parsedDoctorInput.data.session_id;
     try {
       const context = {};
+      context.runtime = {
+        caller: parsedDoctorInput.data.caller ? {
+          endpoint: parsedDoctorInput.data.caller.endpoint ? {
+            host: parsedDoctorInput.data.caller.endpoint.host,
+            port: parsedDoctorInput.data.caller.endpoint.port,
+            baseUrl: parsedDoctorInput.data.caller.endpoint.base_url,
+            hostSource: parsedDoctorInput.data.caller.endpoint.host_source,
+            portSource: parsedDoctorInput.data.caller.endpoint.port_source,
+            metadataPath: parsedDoctorInput.data.caller.endpoint.metadata_path,
+            isolatedMode: parsedDoctorInput.data.caller.endpoint.isolated_mode
+          } : void 0,
+          process: parsedDoctorInput.data.caller.process ? {
+            component: parsedDoctorInput.data.caller.process.component,
+            version: parsedDoctorInput.data.caller.process.version,
+            pid: parsedDoctorInput.data.caller.process.pid,
+            nodeVersion: parsedDoctorInput.data.caller.process.node_version,
+            binaryPath: parsedDoctorInput.data.caller.process.binary_path,
+            argvEntry: parsedDoctorInput.data.caller.process.argv_entry
+          } : void 0
+        } : void 0,
+        core: {
+          endpoint: options.coreRuntime ? {
+            host: options.coreRuntime.host,
+            port: options.coreRuntime.port,
+            baseUrl: `http://${options.coreRuntime.host}:${options.coreRuntime.port}`,
+            hostSource: options.coreRuntime.hostSource,
+            portSource: options.coreRuntime.portSource,
+            metadataPath: options.coreRuntime.metadataPath,
+            isolatedMode: options.coreRuntime.isolatedMode
+          } : void 0,
+          process: {
+            component: "core",
+            version: options.coreVersion,
+            pid: process.pid,
+            nodeVersion: process.version,
+            binaryPath: process.execPath,
+            argvEntry: process.argv[1]
+          }
+        }
+      };
       if (options.registry && sessionId) {
         try {
           const session = options.registry.require(sessionId);
@@ -4268,8 +4669,20 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
         const status = options.extensionBridge.getStatus();
         context.extension = {
           connected: status.connected,
+          version: status.version,
           lastSeenAt: status.lastSeenAt
         };
+        if (status.connected) {
+          context.runtime.extension = {
+            version: status.version,
+            endpoint: status.coreHost && typeof status.corePort === "number" ? {
+              host: status.coreHost,
+              port: status.corePort,
+              baseUrl: `http://${status.coreHost}:${status.corePort}`
+            } : void 0,
+            portSource: status.corePortSource
+          };
+        }
       }
       if (options.debuggerBridge) {
         const settings = options.debuggerBridge.getSettings();
@@ -5110,7 +5523,9 @@ var createCoreServer = (options = {}) => {
     debuggerBridge,
     drive,
     inspectService: inspect,
-    recoveryTracker
+    recoveryTracker,
+    coreRuntime: options.runtime,
+    coreVersion: options.version
   });
   return {
     app,
@@ -5169,7 +5584,7 @@ var resolveSessionCleanupIntervalMs = (ttlMs) => {
 var isAddressInUseError = (error) => Boolean(
   error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE"
 );
-var listenOnPort = (app, extensionBridge, host, port) => new Promise((resolve2, reject) => {
+var listenOnPort = (app, extensionBridge, host, port) => new Promise((resolve3, reject) => {
   const server = (0, import_http.createServer)(app);
   extensionBridge.attach(server);
   const onError = (error) => {
@@ -5178,7 +5593,7 @@ var listenOnPort = (app, extensionBridge, host, port) => new Promise((resolve2,
   };
   const onListening = () => {
     server.off("error", onError);
-    resolve2(server);
+    resolve3(server);
   };
   server.once("error", onError);
   server.once("listening", onListening);
@@ -5218,6 +5633,7 @@ var startCoreServer = async (options = {}) => {
     port: options.port,
     strictEnvPort: false
   });
+  const coreVersion = process.env.BROWSER_BRIDGE_VERSION ?? process.env.npm_package_version;
   logger.info("core.runtime.resolved", {
     host: runtime.host,
     port: runtime.port,
@@ -5230,7 +5646,9 @@ var startCoreServer = async (options = {}) => {
   });
   const { app, registry, extensionBridge } = createCoreServer({
     registry: options.registry,
-    logger
+    logger,
+    runtime,
+    version: coreVersion
   });
   const probePorts = resolveProbePortsForRuntime(runtime);
   let lastAddressInUseError;
@@ -5305,36 +5723,92 @@ var startCoreServer = async (options = {}) => {
 };
 
 // packages/mcp-adapter/src/core-client.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
+var import_node_child_process = require("node:child_process");
+var import_node_path5 = require("node:path");
+var DEFAULT_TIMEOUT_MS2 = 3e4;
 var normalizePath = (path3) => path3.startsWith("/") ? path3 : `/${path3}`;
 var durationMs = (startedAt) => Number((Number(process.hrtime.bigint() - startedAt) / 1e6).toFixed(3));
+var toReadinessErrorEnvelope = (error, baseUrl) => ({
+  ok: false,
+  error: {
+    code: "UNAVAILABLE",
+    message: error instanceof Error ? `Core not ready at ${baseUrl}: ${error.message}` : `Core not ready at ${baseUrl}.`,
+    retryable: true,
+    details: {
+      base_url: baseUrl
+    }
+  }
+});
 var createCoreClient = (options = {}) => {
   const logger = options.logger ?? createJsonlLogger({
     stream: "mcp-adapter",
     cwd: options.cwd
   }).child({ scope: "core-client" });
-  const runtime = resolveCoreRuntime({
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
+  const ensureDaemon = options.ensureDaemon ?? false;
+  const componentVersion = options.componentVersion ?? process.env.BROWSER_BRIDGE_VERSION ?? process.env.npm_package_version;
+  const readiness = createCoreReadinessController({
     host: options.host,
     port: options.port,
     cwd: options.cwd,
-    strictEnvPort: true
+    timeoutMs,
+    ensureDaemon,
+    strictEnvPort: true,
+    fetchImpl,
+    logger,
+    logPrefix: "mcp.core",
+    healthRetryMs: options.healthRetryMs,
+    healthAttempts: options.healthAttempts,
+    spawnDaemon: ensureDaemon ? (runtime) => {
+      const coreEntry = (0, import_node_path5.resolve)(__dirname, "api.js");
+      const startOptions = [];
+      if (runtime.hostSource === "option" || runtime.hostSource === "env") {
+        startOptions.push(`host: ${JSON.stringify(runtime.host)}`);
+      }
+      if (runtime.portSource === "option" || runtime.portSource === "env") {
+        startOptions.push(`port: ${runtime.port}`);
+      }
+      const script = `const { startCoreServer } = require(${JSON.stringify(
+        coreEntry
+      )});
+startCoreServer({ ${startOptions.join(
+        ", "
+      )} })
+  .catch((err) => { console.error(err); process.exit(1); });`;
+      logger.info("mcp.core.spawn.start", {
+        host: runtime.host,
+        port: runtime.port,
+        host_source: runtime.hostSource,
+        port_source: runtime.portSource
+      });
+      const child = spawnImpl(process.execPath, ["-e", script], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env }
+      });
+      child.on("error", (error) => {
+        logger.error("mcp.core.spawn.error", {
+          host: runtime.host,
+          port: runtime.port,
+          error
+        });
+      });
+      child.unref();
+    } : void 0
   });
-  const host = runtime.host;
-  const port = runtime.port;
-  const baseUrl = `http://${host}:${port}`;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const fetchImpl = options.fetchImpl ?? fetch;
   const requestJson = async (path3, body) => {
     const requestPath = normalizePath(path3);
     const startedAt = process.hrtime.bigint();
     logger.debug("mcp.core.request.start", {
       path: requestPath,
-      base_url: baseUrl
+      base_url: readiness.baseUrl
     });
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await fetchImpl(`${baseUrl}${requestPath}`, {
+      const response = await fetchImpl(`${readiness.baseUrl}${requestPath}`, {
         method: "POST",
         headers: {
           "content-type": "application/json"
@@ -5346,7 +5820,7 @@ var createCoreClient = (options = {}) => {
       if (!raw) {
         logger.warn("mcp.core.request.empty_response", {
           path: requestPath,
-          base_url: baseUrl,
+          base_url: readiness.baseUrl,
           status: response.status,
           duration_ms: durationMs(startedAt)
         });
@@ -5356,7 +5830,7 @@ var createCoreClient = (options = {}) => {
         const parsed = JSON.parse(raw);
         logger.debug("mcp.core.request.end", {
           path: requestPath,
-          base_url: baseUrl,
+          base_url: readiness.baseUrl,
           status: response.status,
           duration_ms: durationMs(startedAt)
         });
@@ -5365,7 +5839,7 @@ var createCoreClient = (options = {}) => {
         const message = error instanceof Error ? error.message : "Unknown JSON parse error";
         logger.error("mcp.core.request.invalid_json", {
           path: requestPath,
-          base_url: baseUrl,
+          base_url: readiness.baseUrl,
           status: response.status,
           duration_ms: durationMs(startedAt),
           error
@@ -5375,7 +5849,7 @@ var createCoreClient = (options = {}) => {
     } catch (error) {
       logger.error("mcp.core.request.failed", {
         path: requestPath,
-        base_url: baseUrl,
+        base_url: readiness.baseUrl,
         duration_ms: durationMs(startedAt),
         error
       });
@@ -5385,9 +5859,47 @@ var createCoreClient = (options = {}) => {
     }
   };
   const post = async (path3, body) => {
-    return requestJson(path3, body);
+    try {
+      await readiness.ensureReady();
+    } catch (error) {
+      logger.warn("mcp.core.ensure_ready.unavailable", {
+        base_url: readiness.baseUrl,
+        error
+      });
+      throw toReadinessErrorEnvelope(error, readiness.baseUrl);
+    }
+    readiness.refreshRuntime();
+    const payload = path3 === "/diagnostics/doctor" && (!body || typeof body === "object" && !Array.isArray(body)) ? {
+      ...body && typeof body === "object" ? body : {},
+      caller: {
+        endpoint: {
+          host: readiness.runtime.host,
+          port: readiness.runtime.port,
+          base_url: readiness.baseUrl,
+          host_source: readiness.runtime.hostSource,
+          port_source: readiness.runtime.portSource,
+          metadata_path: readiness.runtime.metadataPath,
+          isolated_mode: readiness.runtime.isolatedMode
+        },
+        process: {
+          component: "mcp",
+          version: componentVersion,
+          pid: process.pid,
+          node_version: process.version,
+          binary_path: process.execPath,
+          argv_entry: process.argv[1]
+        }
+      }
+    } : body;
+    return requestJson(path3, payload);
+  };
+  return {
+    get baseUrl() {
+      return readiness.baseUrl;
+    },
+    ensureReady: readiness.ensureReady,
+    post
   };
-  return { baseUrl, post };
 };
 
 // packages/mcp-adapter/src/tools.ts
@@ -5784,10 +6296,11 @@ var TOOL_DEFINITIONS = [
     }
   }
 ];
-var createToolHandler = (client, corePath) => {
+var createToolHandler = (clientProvider, corePath) => {
   return (async (args, _extra) => {
     void _extra;
     try {
+      const client = typeof clientProvider === "function" ? await clientProvider() : clientProvider;
       const envelopeResult = await client.post(corePath, args);
       return toToolResult(envelopeResult);
     } catch (error) {
@@ -5799,7 +6312,7 @@ var createToolHandler = (client, corePath) => {
     }
   });
 };
-var registerBrowserBridgeTools = (server, client) => {
+var registerBrowserBridgeTools = (server, clientProvider) => {
   for (const tool of TOOL_DEFINITIONS) {
     server.registerTool(
       tool.name,
@@ -5809,7 +6322,7 @@ var registerBrowserBridgeTools = (server, client) => {
         inputSchema: tool.config.inputSchema,
         outputSchema: tool.config.outputSchema
       },
-      createToolHandler(client, tool.config.corePath)
+      createToolHandler(clientProvider, tool.config.corePath)
     );
   }
 };
@@ -5819,53 +6332,290 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// packages/mcp-adapter/src/deferred-logger.ts
+var LOG_LEVEL_PRIORITY2 = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var isEnabled = (state, level) => LOG_LEVEL_PRIORITY2[level] >= LOG_LEVEL_PRIORITY2[state.level];
+var enqueue = (state, entry) => {
+  if (state.buffered.length >= state.maxBufferEntries) {
+    state.buffered.shift();
+    state.droppedEntries += 1;
+  }
+  state.buffered.push(entry);
+};
+var flushBuffered = (state) => {
+  const destination = state.destination;
+  if (!destination) {
+    return;
+  }
+  if (state.droppedEntries > 0) {
+    destination.warn("mcp.log.buffer.dropped", {
+      dropped_entries: state.droppedEntries
+    });
+    state.droppedEntries = 0;
+  }
+  for (const entry of state.buffered) {
+    destination.log(entry.level, entry.event, {
+      ...entry.bindings,
+      ...entry.fields
+    });
+  }
+  state.buffered.length = 0;
+};
+var buildLogger2 = (state, bindings) => {
+  const log = (level, event, fields = {}) => {
+    if (!isEnabled(state, level)) {
+      return;
+    }
+    if (state.destination) {
+      state.destination.log(level, event, {
+        ...bindings,
+        ...fields
+      });
+      return;
+    }
+    enqueue(state, {
+      level,
+      event,
+      fields: { ...fields },
+      bindings: { ...bindings }
+    });
+  };
+  return {
+    stream: state.stream,
+    get level() {
+      return state.destination?.level ?? state.level;
+    },
+    get logDir() {
+      return state.destination?.logDir ?? "";
+    },
+    get filePath() {
+      return state.destination?.filePath ?? "";
+    },
+    child: (childBindings) => buildLogger2(state, {
+      ...bindings,
+      ...childBindings
+    }),
+    log,
+    debug: (event, fields) => log("debug", event, fields),
+    info: (event, fields) => log("info", event, fields),
+    warn: (event, fields) => log("warn", event, fields),
+    error: (event, fields) => log("error", event, fields)
+  };
+};
+var createDeferredJsonlLogger = (options) => {
+  const state = {
+    stream: options.stream,
+    level: options.level ?? "debug",
+    destination: null,
+    buffered: [],
+    droppedEntries: 0,
+    maxBufferEntries: Math.max(1, options.maxBufferEntries ?? 2e3)
+  };
+  return {
+    logger: buildLogger2(state, options.bindings ?? {}),
+    activate: () => {
+      if (!state.destination) {
+        state.destination = createJsonlLogger(options);
+      }
+      flushBuffered(state);
+      return state.destination;
+    },
+    isActivated: () => state.destination !== null
+  };
+};
+
+// packages/mcp-adapter/src/server.ts
 var DEFAULT_SERVER_NAME = "browser-bridge";
 var DEFAULT_SERVER_VERSION = "0.0.0";
-var resolveAdapterLogger = (options) => options.logger ?? createJsonlLogger({
-  stream: "mcp-adapter",
-  cwd: options.cwd
+var ENV_MCP_EAGER = "BROWSER_BRIDGE_MCP_EAGER";
+var ENV_LEGACY_MCP_EAGER = "BROWSER_VISION_MCP_EAGER";
+var parseBoolean2 = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return void 0;
+};
+var resolveEagerMode = (explicit) => {
+  if (typeof explicit === "boolean") {
+    return explicit;
+  }
+  const envValue = parseBoolean2(process.env[ENV_MCP_EAGER]) ?? parseBoolean2(process.env[ENV_LEGACY_MCP_EAGER]);
+  return envValue ?? false;
+};
+var toCoreClientOptions = (options, logger) => ({
+  host: options.host,
+  port: options.port,
+  cwd: options.cwd,
+  timeoutMs: options.timeoutMs,
+  ensureDaemon: options.ensureDaemon ?? true,
+  componentVersion: options.version ?? DEFAULT_SERVER_VERSION,
+  healthRetryMs: options.healthRetryMs,
+  healthAttempts: options.healthAttempts,
+  fetchImpl: options.fetchImpl,
+  spawnImpl: options.spawnImpl,
+  logger
 });
-var createMcpServer = (options = {}) => {
-  const logger = resolveAdapterLogger(options);
+var buildInitializationError = (error) => {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown initialization failure.";
+  return {
+    ok: false,
+    error: {
+      code: "UNAVAILABLE",
+      message: `MCP runtime initialization failed: ${message}`,
+      retryable: true,
+      details: {
+        phase: "mcp_runtime_init"
+      }
+    }
+  };
+};
+var resolveDeferredLoggerController = (options) => {
+  if (options.logger) {
+    return {
+      logger: options.logger,
+      activate: () => void 0
+    };
+  }
+  const deferred = createDeferredJsonlLogger({
+    stream: "mcp-adapter",
+    cwd: options.cwd
+  });
+  return {
+    logger: deferred.logger,
+    activate: () => {
+      deferred.activate();
+    }
+  };
+};
+var createRuntimeController = (options) => {
+  const deferredLogger = resolveDeferredLoggerController(options);
+  const logger = deferredLogger.logger;
+  const coreLogger = logger.child({ scope: "core-client" });
+  let initializedClient = null;
+  let initializationPromise = null;
+  const createClient = async () => {
+    if (options.coreClient) {
+      return options.coreClient;
+    }
+    if (options.coreClientFactory) {
+      return await options.coreClientFactory(coreLogger);
+    }
+    return createCoreClient(toCoreClientOptions(options, coreLogger));
+  };
+  const proxyClient = {
+    get baseUrl() {
+      return initializedClient?.baseUrl ?? "";
+    },
+    ensureReady: async () => {
+      await ensureInitialized();
+    },
+    post: async (path3, body) => {
+      const client = await ensureInitialized();
+      return client.post(path3, body);
+    }
+  };
+  const ensureInitialized = async () => {
+    if (initializedClient) {
+      return initializedClient;
+    }
+    if (!initializationPromise) {
+      initializationPromise = (async () => {
+        logger.info("mcp.runtime.init.begin");
+        try {
+          const candidate = await createClient();
+          const maybeEnsureReady = candidate.ensureReady;
+          if (typeof maybeEnsureReady === "function") {
+            await maybeEnsureReady.call(candidate);
+          }
+          deferredLogger.activate();
+          initializedClient = candidate;
+          logger.info("mcp.runtime.init.ready", {
+            core_base_url: candidate.baseUrl
+          });
+          return candidate;
+        } catch (error) {
+          logger.error("mcp.runtime.init.failed", {
+            error
+          });
+          throw buildInitializationError(error);
+        }
+      })();
+      initializationPromise = initializationPromise.catch((error) => {
+        initializationPromise = null;
+        throw error;
+      });
+    }
+    return initializationPromise;
+  };
+  return {
+    logger,
+    client: options.coreClient ?? proxyClient,
+    ensureInitialized,
+    isInitialized: () => initializedClient !== null
+  };
+};
+var createMcpServerBootstrap = (options = {}) => {
+  const runtime = createRuntimeController(options);
   const server = new import_mcp.McpServer({
     name: options.name ?? DEFAULT_SERVER_NAME,
     version: options.version ?? DEFAULT_SERVER_VERSION
   });
-  const client = options.coreClient ?? createCoreClient({
-    ...options,
-    logger: logger.child({ scope: "core-client" })
-  });
-  registerBrowserBridgeTools(server, client);
-  logger.info("mcp.server.created", {
+  registerBrowserBridgeTools(server, runtime.ensureInitialized);
+  runtime.logger.info("mcp.server.created", {
     name: options.name ?? DEFAULT_SERVER_NAME,
     version: options.version ?? DEFAULT_SERVER_VERSION,
-    core_base_url: client.baseUrl
+    lazy_init: true
   });
-  return { server, client };
+  return {
+    server,
+    client: runtime.client,
+    logger: runtime.logger,
+    ensureInitialized: runtime.ensureInitialized,
+    isInitialized: runtime.isInitialized
+  };
 };
 var startMcpServer = async (options = {}) => {
-  const logger = resolveAdapterLogger(options);
-  logger.info("mcp.stdio.start.begin", {
+  const eager = resolveEagerMode(options.eager);
+  const handle = createMcpServerBootstrap(options);
+  handle.logger.info("mcp.stdio.start.begin", {
     name: options.name ?? DEFAULT_SERVER_NAME,
-    version: options.version ?? DEFAULT_SERVER_VERSION
-  });
-  const handle = createMcpServer({
-    ...options,
-    logger
+    version: options.version ?? DEFAULT_SERVER_VERSION,
+    eager
   });
   const transport = new import_stdio.StdioServerTransport();
   try {
+    if (eager) {
+      await handle.ensureInitialized();
+    }
     await handle.server.connect(transport);
-    logger.info("mcp.stdio.start.ready", {
-      core_base_url: handle.client.baseUrl
+    handle.logger.info("mcp.stdio.start.ready", {
+      core_base_url: handle.isInitialized() ? handle.client.baseUrl : null,
+      eager
     });
   } catch (error) {
-    logger.error("mcp.stdio.start.failed", {
+    handle.logger.error("mcp.stdio.start.failed", {
       error
     });
     throw error;
   }
-  return { ...handle, transport };
+  return {
+    server: handle.server,
+    client: handle.client,
+    transport
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {