@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

package/chunks/{run-qwen-serve-REKSTYRA.js → run-qwen-serve-PQV7QOHZ.js}

@@ -1,7 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-GHOTR7HL.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
+  ClientMcpSenderRegistry,
   SERVE_CAPABILITY_REGISTRY,
   allowOriginCors,
   allowOriginMode,
@@ -20,27 +24,29 @@ import {
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-FPACXT7T.js";
+} from "./chunk-MTJVHQDP.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
 import {
   getCliVersion
-} from "./chunk-BS64PXY3.js";
+} from "./chunk-HIYUAXBG.js";
+import "./chunk-EWALXUAD.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-SEZC2725.js";
-import {
-  writeStderrLine,
-  writeStdoutLine
-} from "./chunk-Y6Z2O3WR.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-3RJ3ZPPR.js";
+} from "./chunk-KKQWC6WS.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
-} from "./chunk-UN3C6GOR.js";
+} from "./chunk-PPFWEV7G.js";
+import {
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-Y6Z2O3WR.js";
+import "./chunk-QYUE6W3T.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-UWCTAVOD.js";
@@ -347,10 +353,14 @@ __name(initDaemonLogger, "initDaemonLogger");
 
 // packages/cli/src/serve/run-qwen-serve.ts
 var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
+var QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV = "QWEN_SERVE_CLIENT_MCP_OVER_WS";
+var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
 var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
 var DEFAULT_RUNTIME_STARTUP_TIMEOUT_MS = 12e4;
+var FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS = 50;
+var FAST_PATH_RUNTIME_START_FALLBACK_MS = 1e3;
 var RUNTIME_STARTUP_TIMEOUT_ENV = "QWEN_SERVE_RUNTIME_STARTUP_TIMEOUT_MS";
 var MAX_EVENT_RING_SIZE = 1e6;
 var DEFAULT_MAX_SESSIONS = 20;
@@ -515,7 +525,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-4F6FBZFI.js");
+  coreRuntimePromise ??= import("./src-PNZYGM3R.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -545,11 +555,13 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-WJTCBIRA.js"),
-    import("./loadedSettingsAdapter-XIUTN245.js")
-  ]).then(([settings, loadedSettingsAdapter]) => ({
+    import("./settings-DFTYMJYF.js"),
+    import("./loadedSettingsAdapter-H27JMTLU.js"),
+    import("./trustedFolders-SJRXNHZE.js")
+  ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
-    loadedSettingsAdapter
+    loadedSettingsAdapter,
+    trustedFolders
   }));
   return settingsRuntimePromise;
 }
@@ -560,15 +572,17 @@ async function loadServeRuntimeModules() {
     bridgeModule,
     spawnChannelModule,
     workspaceModule,
+    workspaceTypesModule,
     daemonStatusProviderModule,
     workspaceProvidersStatusModule
   ] = await Promise.all([
-    import("./server-BV5TZUMU.js"),
-    import("./bridge-4LV2HBH2.js"),
-    import("./spawnChannel-EI2E5BCW.js"),
-    import("./workspace-service-OM5D4OI2.js"),
-    import("./daemon-status-provider-CSL3BUOY.js"),
-    import("./workspace-providers-status-ZIR5EPOO.js")
+    import("./server-P4YIH35I.js"),
+    import("./bridge-HZVAUTMX.js"),
+    import("./spawnChannel-DHRIMDVL.js"),
+    import("./workspace-service-34C7SUBU.js"),
+    import("./types-QX5C3CHJ.js"),
+    import("./daemon-status-provider-42JEXENZ.js"),
+    import("./workspace-providers-status-GOCWYDMK.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -577,6 +591,7 @@ async function loadServeRuntimeModules() {
     createAcpSessionBridge: bridgeModule.createAcpSessionBridge,
     createSpawnChannelFactory: spawnChannelModule.createSpawnChannelFactory,
     createDaemonWorkspaceService: workspaceModule.createDaemonWorkspaceService,
+    WorkspaceSettingsPartialPersistError: workspaceTypesModule.WorkspaceSettingsPartialPersistError,
     createDaemonStatusProvider: daemonStatusProviderModule.createDaemonStatusProvider,
     createWorkspaceProvidersStatusProvider: workspaceProvidersStatusModule.createWorkspaceProvidersStatusProvider
   };
@@ -612,7 +627,11 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled) {
     persistSettingAvailable: true,
     sessionShellCommandEnabled,
     rateLimit: opts.rateLimit === true,
-    reloadAvailable: true
+    reloadAvailable: true,
+    // Advertise the same WS feature flags as the runtime path (serve-features.ts)
+    // so the bootstrap `/capabilities` window doesn't briefly under-report them.
+    clientMcpOverWsEnabled: opts.clientMcpOverWs === true,
+    cdpTunnelOverWsEnabled: opts.cdpTunnelOverWs === true
   });
 }
 __name(currentServeFeaturesForRunQwenServe, "currentServeFeaturesForRunQwenServe");
@@ -737,6 +756,14 @@ async function waitForRuntimeStartingForShutdown(runtimeStarting, daemonLog, tim
   });
 }
 __name(waitForRuntimeStartingForShutdown, "waitForRuntimeStartingForShutdown");
+var BOOTSTRAP_HEALTH_PATH = "/health";
+var BOOTSTRAP_CAPABILITIES_PATH = "/capabilities";
+var BOOTSTRAP_DAEMON_STATUS_PATH = "/daemon/status";
+var BOOTSTRAP_SERVE_PATHS = /* @__PURE__ */ new Set([
+  BOOTSTRAP_HEALTH_PATH,
+  BOOTSTRAP_CAPABILITIES_PATH,
+  BOOTSTRAP_DAEMON_STATUS_PATH
+]);
 function createBootstrapServeApp(input) {
   const {
     opts,
@@ -747,7 +774,8 @@ function createBootstrapServeApp(input) {
     qwenCodeVersion,
     sessionShellCommandEnabled,
     permissionPolicy,
-    getRuntimeError
+    getRuntimeError,
+    onHealthServed
   } = input;
   const app = (0, import_express.default)();
   installSameOriginOriginStrip(app, getPort);
@@ -766,18 +794,21 @@ function createBootstrapServeApp(input) {
       });
       return;
     }
+    if (onHealthServed) {
+      res.once("finish", onHealthServed);
+    }
     res.status(200).json({ status: "ok" });
   }, "healthHandler");
   const loopback = isLoopbackBind(opts.hostname);
   const exposeHealthPreAuth = loopback && !opts.requireAuth;
   if (exposeHealthPreAuth) {
-    app.get("/health", healthHandler);
+    app.get(BOOTSTRAP_HEALTH_PATH, healthHandler);
   }
   app.use(bearerAuth(opts.token));
   if (!exposeHealthPreAuth) {
-    app.get("/health", healthHandler);
+    app.get(BOOTSTRAP_HEALTH_PATH, healthHandler);
   }
-  app.get("/capabilities", (_req, res) => {
+  app.get(BOOTSTRAP_CAPABILITIES_PATH, (_req, res) => {
     res.status(200).json(
       createBootstrapCapabilities({
         opts,
@@ -788,7 +819,7 @@ function createBootstrapServeApp(input) {
       })
     );
   });
-  app.get("/daemon/status", (req, res) => {
+  app.get(BOOTSTRAP_DAEMON_STATUS_PATH, (req, res) => {
     const detail = parseDaemonStatusDetail(req.query["detail"]);
     if (!detail.ok || !detail.detail) {
       res.status(400).json({
@@ -910,16 +941,58 @@ function createBootstrapServeApp(input) {
   return app;
 }
 __name(createBootstrapServeApp, "createBootstrapServeApp");
-function createDelegatingServeApp(bootstrapApp, getRuntimeApp) {
+function createDelegatingServeApp(bootstrapApp, getRuntimeApp, options = {}) {
   const app = (0, import_express.default)();
   app.use((req, res, next) => {
-    const target = getRuntimeApp() ?? bootstrapApp;
-    const handler = target;
-    handler(req, res, next);
+    const dispatch = /* @__PURE__ */ __name(async () => {
+      let target = getRuntimeApp();
+      if (!target && options.waitForDeferredRuntimeRoutes === true && !isBootstrapServeRoute(req) && !isCorsPreflightRequest(req) && options.startRuntime && options.runtimeReady) {
+        if (options.authenticateDeferredRuntimeRequest && !runSynchronousRequestGate(
+          options.authenticateDeferredRuntimeRequest,
+          req,
+          res,
+          next
+        )) {
+          return;
+        }
+        options.startRuntime();
+        try {
+          await options.runtimeReady;
+        } catch {
+        }
+        target = getRuntimeApp();
+      }
+      const handler = target ?? bootstrapApp;
+      handler(req, res, next);
+    }, "dispatch");
+    void dispatch().catch(next);
   });
   return app;
 }
 __name(createDelegatingServeApp, "createDelegatingServeApp");
+function isBootstrapServeRoute(req) {
+  const path2 = req.path.length > 1 && req.path.endsWith("/") ? req.path.slice(0, -1) : req.path;
+  return BOOTSTRAP_SERVE_PATHS.has(path2);
+}
+__name(isBootstrapServeRoute, "isBootstrapServeRoute");
+function isCorsPreflightRequest(req) {
+  return req.method === "OPTIONS" && Boolean(req.headers.origin) && Boolean(
+    req.headers["access-control-request-method"] || req.headers["access-control-request-headers"]
+  );
+}
+__name(isCorsPreflightRequest, "isCorsPreflightRequest");
+function runSynchronousRequestGate(handler, req, res, next) {
+  let passed = false;
+  handler(req, res, (err) => {
+    if (err) {
+      next(err);
+      return;
+    }
+    passed = true;
+  });
+  return passed;
+}
+__name(runSynchronousRequestGate, "runSynchronousRequestGate");
 async function runQwenServe(optsIn, deps = {}) {
   const runStartedAt = performance.now();
   const shouldPreheat = !deps.bridge && shouldPreheatBridge(deps);
@@ -952,7 +1025,16 @@ async function runQwenServe(optsIn, deps = {}) {
     ...optsIn,
     token,
     promptDeadlineMs,
-    writerIdleTimeoutMs
+    writerIdleTimeoutMs,
+    // Reverse tool channel (issue #5626, Phase 2). Opt-in via env until the
+    // public contract settles — the WS `mcp_register` / `mcp_message` frames
+    // and the child↔parent `client_mcp/message` round-trip stay dormant
+    // otherwise. An explicit `clientMcpOverWs` in `optsIn` (embedded callers)
+    // still wins.
+    clientMcpOverWs: optsIn.clientMcpOverWs ?? process.env[QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV] === "1",
+    // CDP tunnel (Plan C, issue #5626). Opt-in via env until the contract
+    // settles; an explicit `cdpTunnelOverWs` in `optsIn` still wins.
+    cdpTunnelOverWs: optsIn.cdpTunnelOverWs ?? process.env[QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV] === "1"
   };
   validateRateLimitOptions(opts);
   if (!opts.hostname.startsWith("[") && opts.hostname.split(":").length === 2) {
@@ -1132,10 +1214,25 @@ async function runQwenServe(optsIn, deps = {}) {
   }
   const childEnvOverrides = {
     QWEN_SERVE_MCP_CLIENT_BUDGET: opts.mcpClientBudget !== void 0 ? String(opts.mcpClientBudget) : void 0,
-    QWEN_SERVE_MCP_BUDGET_MODE: opts.mcpBudgetMode
+    QWEN_SERVE_MCP_BUDGET_MODE: opts.mcpBudgetMode,
+    // CDP tunnel (Plan C, #5626): forward the flag + bound port so the spawned
+    // ACP child can auto-register chrome-devtools-mcp against this `/cdp`
+    // endpoint. Only meaningful with a fixed `--port`: the override map is frozen
+    // at bridge construction, so an ephemeral `--port 0` (resolved only after
+    // `listen`) can't be threaded here. Leave the port unset in that case so the
+    // child surfaces a clear diagnostic instead of a bogus port "0".
+    QWEN_SERVE_CDP_TUNNEL_OVER_WS: opts.cdpTunnelOverWs ? "1" : void 0,
+    QWEN_SERVE_CDP_TUNNEL_PORT: opts.cdpTunnelOverWs && opts.port > 0 ? String(opts.port) : void 0,
+    // Tell the child whether `/cdp` requires bearer auth. The ACP child can't
+    // inherit QWEN_SERVER_TOKEN (the spawn path scrubs it) and chrome-devtools-
+    // mcp is launched with `--wsEndpoint` only, so it can't authenticate against
+    // an auth-gated `/cdp`. The child uses this flag to skip auto-registering the
+    // browser tools (with a diagnostic) instead of registering tools that can't
+    // connect. See buildCdpTunnelMcpServer in acpAgent.ts.
+    QWEN_SERVE_CDP_TUNNEL_AUTH_REQUIRED: opts.cdpTunnelOverWs && (token || opts.requireAuth) ? "1" : void 0
   };
-  const cliVersion = await getCliVersion();
-  const trustedWorkspace = deps.trustedWorkspace ?? true;
+  const cliVersionPromise = getCliVersion();
+  let cliVersion;
   const diagnosticSink = /* @__PURE__ */ __name((line, level) => daemonLog.raw(line, level), "diagnosticSink");
   let actualPort = opts.port;
   const webShellDir = opts.serveWebShell === false ? void 0 : resolveWebShellDir();
@@ -1167,6 +1264,9 @@ async function runQwenServe(optsIn, deps = {}) {
   let markRuntimeReady;
   let markRuntimeFailed;
   let runtimeStartupSettled = false;
+  let startRuntimeAfterHealth;
+  let startRuntimeForRequest;
+  const deferRuntimeUntilFirstHealth = deps.resolveOnListen === true && deps.deferRuntimeUntilFirstHealth === true;
   const runtimeReady = new Promise((resolve, reject) => {
     markRuntimeReady = resolve;
     markRuntimeFailed = reject;
@@ -1178,11 +1278,13 @@ async function runQwenServe(optsIn, deps = {}) {
     () => runtimeStartupError
   );
   const buildRuntime = /* @__PURE__ */ __name(async () => {
-    const [runtime, core, settingsRuntime] = await Promise.all([
+    const [runtime, core, settingsRuntime, resolvedCliVersion] = await Promise.all([
       loadServeRuntimeModules(),
       loadCoreRuntime(),
-      loadSettingsRuntimeModules()
+      loadSettingsRuntimeModules(),
+      cliVersionPromise
     ]);
+    cliVersion = resolvedCliVersion;
     let runtimeBootSettings;
     try {
       runtimeBootSettings = settingsRuntime.settings.loadSettings(boundWorkspace);
@@ -1191,15 +1293,35 @@ async function runQwenServe(optsIn, deps = {}) {
         `qwen serve: could not read full settings for runtime startup (${err instanceof Error ? err.message : String(err)}); falling back to defaults.`
       );
     }
+    const trustedWorkspace = deps.trustedWorkspace ?? (runtimeBootSettings ? settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+      runtimeBootSettings.merged,
+      boundWorkspace
+    ).effective.state === "trusted" : true);
+    if (deps.trustedWorkspace === void 0 && runtimeBootSettings && !trustedWorkspace) {
+      daemonLog.warn(
+        "workspace file writes are disabled because the bound workspace is not trusted",
+        { workspace: boundWorkspace }
+      );
+    }
     const daemonWorkspaceHash = core.hashDaemonWorkspace(boundWorkspace);
-    const daemonTelemetrySettings = await core.resolveTelemetrySettings({
-      env: process.env,
-      settings: runtimeBootSettings?.merged.telemetry
-    });
+    let daemonTelemetrySettings;
+    try {
+      daemonTelemetrySettings = await core.resolveTelemetrySettings({
+        env: process.env,
+        settings: runtimeBootSettings?.merged.telemetry
+      });
+    } catch (err) {
+      if (err instanceof core.FatalConfigError) {
+        throw new core.FatalConfigError(
+          `Invalid telemetry configuration: ${err.message}.`
+        );
+      }
+      throw err;
+    }
     core.initializeTelemetry(
       createDaemonTelemetryRuntimeConfig(
         daemonTelemetrySettings,
-        cliVersion,
+        resolvedCliVersion,
         `daemon:${daemonWorkspaceHash}:${process.pid}`,
         {
           otlpEndpoint: core.DEFAULT_OTLP_ENDPOINT,
@@ -1257,6 +1379,7 @@ async function runQwenServe(optsIn, deps = {}) {
     });
     const statusProvider = runtime.createDaemonStatusProvider();
     const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider();
+    const clientMcpSenderRegistry = new ClientMcpSenderRegistry();
     const persistDisabledToolsFn = /* @__PURE__ */ __name((workspace, toolName, enabled) => withSettingsLock(workspace, async () => {
       const fresh = settingsRuntime.settings.loadSettings(workspace);
       const wsScope = fresh.forScope(WORKSPACE_SETTING_SCOPE).settings;
@@ -1271,7 +1394,42 @@ async function runQwenServe(optsIn, deps = {}) {
         [...next].sort()
       );
     }), "persistDisabledToolsFn");
+    const persistSettingFn = /* @__PURE__ */ __name((workspace, scope, key, value) => withSettingsLock(workspace, async () => {
+      const fresh = settingsRuntime.settings.loadSettings(workspace);
+      fresh.setValue(scope, key, value);
+      return fresh;
+    }), "persistSettingFn");
+    const persistSettingsFn = /* @__PURE__ */ __name((workspace, writes) => withSettingsLock(workspace, async () => {
+      const fresh = settingsRuntime.settings.loadSettings(workspace);
+      const writesByScope = /* @__PURE__ */ new Map();
+      for (const write of writes) {
+        writesByScope.set(
+          write.scope,
+          (writesByScope.get(write.scope) ?? 0) + 1
+        );
+      }
+      const committedScopes = /* @__PURE__ */ new Set();
+      let committed = 0;
+      try {
+        fresh.setValues(writes, (scope) => {
+          committedScopes.add(scope);
+          committed += writesByScope.get(scope) ?? 0;
+        });
+      } catch (err) {
+        const failedWrite = writes.find((write) => !committedScopes.has(write.scope)) ?? writes[committed];
+        const message = `persistSettings partial failure (workspace=${workspace}, committed=${committed}/${writes.length}, failedKey=${failedWrite?.key ?? "<unknown>"}, failedScope=${failedWrite?.scope ?? "<unknown>"}): ${err instanceof Error ? err.message : String(err)}`;
+        writeStderrLine(`qwen serve: ${message}`);
+        throw new runtime.WorkspaceSettingsPartialPersistError(
+          message,
+          writes.filter((write) => committedScopes.has(write.scope)),
+          err
+        );
+      }
+    }), "persistSettingsFn");
     const bridge = deps.bridge ?? runtime.createAcpSessionBridge({
+      // Reverse tool channel: let `BridgeClient.extMethod` reach the WS
+      // connection that hosts a named client MCP server (#5626).
+      clientMcpSender: clientMcpSenderRegistry.lookup,
       maxSessions: opts.maxSessions,
       ...opts.maxPendingPromptsPerSession !== void 0 ? { maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession } : {},
       ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
@@ -1305,6 +1463,8 @@ async function runQwenServe(optsIn, deps = {}) {
       workspaceProvidersStatusProvider,
       isChannelLive: /* @__PURE__ */ __name(() => bridge.isChannelLive(), "isChannelLive"),
       persistDisabledTools: persistDisabledToolsFn,
+      persistSetting: persistSettingFn,
+      persistSettings: persistSettingsFn,
       reloadDaemonEnv: /* @__PURE__ */ __name((workspace) => withSettingsLock(workspace, async () => {
         const fresh = settingsRuntime.settings.loadSettings(workspace, {
           skipLoadEnvironment: true
@@ -1328,16 +1488,17 @@ async function runQwenServe(optsIn, deps = {}) {
       bridge,
       webShellDir,
       boundWorkspace,
-      qwenCodeVersion: cliVersion,
+      qwenCodeVersion: resolvedCliVersion,
       startup,
       fsFactory,
       daemonLog,
       workspace: workspaceService,
+      // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
+      // so the WS provider and the child-answering bridge share one sender map.
+      clientMcpSenderRegistry,
       persistDisabledTools: persistDisabledToolsFn,
-      persistSetting: /* @__PURE__ */ __name((workspace, scope, key, value) => withSettingsLock(workspace, async () => {
-        const fresh = settingsRuntime.settings.loadSettings(workspace);
-        fresh.setValue(scope, key, value);
-      }), "persistSetting"),
+      persistSetting: persistSettingFn,
+      persistSettings: persistSettingsFn,
       installAuthProvider: /* @__PURE__ */ __name((req) => withSettingsLock(
         boundWorkspace,
         async () => {
@@ -1351,23 +1512,26 @@ async function runQwenServe(optsIn, deps = {}) {
           });
           const plan = core.buildInstallPlan(provider, inputs);
           const fresh = settingsRuntime.settings.loadSettings(boundWorkspace);
+          const adapter = settingsRuntime.loadedSettingsAdapter.createLoadedSettingsAdapter(
+            fresh
+          );
           await core.applyProviderInstallPlan(plan, {
-            settings: settingsRuntime.loadedSettingsAdapter.createLoadedSettingsAdapter(
-              fresh
-            ),
+            settings: adapter,
             doRefreshAuth: false
           });
           core.emitDaemonLog("Auth provider installed.", {
             "qwen-code.daemon.auth.provider_id": provider.id,
             "qwen-code.daemon.auth.auth_type": plan.authType
           });
+          const effectiveModelId = adapter.getValue("model.name") ?? plan.modelSelection?.modelId;
+          const effectiveBaseUrl = adapter.getValue("model.baseUrl") ?? plan.modelSelection?.baseUrl ?? inputs.baseUrl;
           return {
             v: 1,
             providerId: provider.id,
             providerLabel: provider.label,
             authType: plan.authType,
-            ...plan.modelSelection?.modelId ? { modelId: plan.modelSelection.modelId } : {},
-            ...inputs.baseUrl ? { baseUrl: inputs.baseUrl } : {},
+            ...effectiveModelId ? { modelId: effectiveModelId } : {},
+            ...effectiveBaseUrl ? { baseUrl: effectiveBaseUrl } : {},
             message: `Successfully configured ${provider.label}. Use /model to switch models.`
           };
         }
@@ -1383,6 +1547,7 @@ async function runQwenServe(optsIn, deps = {}) {
     runtimeStartupSettled = true;
     markRuntimeReady();
   }
+  cliVersion ??= await cliVersionPromise;
   const bootstrapApp = createBootstrapServeApp({
     opts,
     getPort: /* @__PURE__ */ __name(() => actualPort, "getPort"),
@@ -1392,9 +1557,15 @@ async function runQwenServe(optsIn, deps = {}) {
     qwenCodeVersion: cliVersion,
     sessionShellCommandEnabled,
     permissionPolicy,
-    getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError")
+    getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
+    onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
+  });
+  const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp, {
+    waitForDeferredRuntimeRoutes: deferRuntimeUntilFirstHealth,
+    startRuntime: /* @__PURE__ */ __name(() => startRuntimeForRequest?.(), "startRuntime"),
+    runtimeReady,
+    authenticateDeferredRuntimeRequest: bearerAuth(opts.token)
   });
-  const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp);
   let listenHostname = opts.hostname;
   if (opts.hostname.startsWith("[")) {
     const inner = opts.hostname.slice(1, -1);
@@ -1447,6 +1618,8 @@ async function runQwenServe(optsIn, deps = {}) {
       let shuttingDown = false;
       let closePromise;
       let runtimeStartupTimer;
+      let runtimeStartAfterHealthTimer;
+      let runtimeStartFallbackTimer;
       const runtimeStartupTimeoutMs = resolveRuntimeStartupTimeoutMs(
         deps.runtimeStartupTimeoutMs
       );
@@ -1455,6 +1628,27 @@ async function runQwenServe(optsIn, deps = {}) {
         clearTimeout(runtimeStartupTimer);
         runtimeStartupTimer = void 0;
       }, "clearRuntimeStartupTimer");
+      const clearRuntimeStartFallbackTimer = /* @__PURE__ */ __name(() => {
+        if (!runtimeStartFallbackTimer) return;
+        clearTimeout(runtimeStartFallbackTimer);
+        runtimeStartFallbackTimer = void 0;
+      }, "clearRuntimeStartFallbackTimer");
+      const clearRuntimeStartAfterHealthTimer = /* @__PURE__ */ __name(() => {
+        if (!runtimeStartAfterHealthTimer) return;
+        clearTimeout(runtimeStartAfterHealthTimer);
+        runtimeStartAfterHealthTimer = void 0;
+      }, "clearRuntimeStartAfterHealthTimer");
+      const cancelDeferredRuntimeStartup = /* @__PURE__ */ __name(() => {
+        if (!deferRuntimeUntilFirstHealth || runtimeStarting || runtimeStartupSettled)
+          return;
+        daemonLog.info(
+          "deferred runtime: cancelled, server closed before startup"
+        );
+        runtimeStartupSettled = true;
+        const error = new Error(RUNTIME_STARTUP_CANCELLED_MESSAGE);
+        runtimeStartupError = error.message;
+        markRuntimeFailed(error);
+      }, "cancelDeferredRuntimeStartup");
       const shutdownBridgeAfterFailedStartup = /* @__PURE__ */ __name(async (bridge) => {
         if (!bridge || deps.bridge) return;
         try {
@@ -1511,6 +1705,8 @@ async function runQwenServe(optsIn, deps = {}) {
       }, "startBridgePreheat");
       const startRuntime = /* @__PURE__ */ __name(() => {
         if (runtimeStarting) return;
+        clearRuntimeStartAfterHealthTimer();
+        clearRuntimeStartFallbackTimer();
         runtimeStarting = buildRuntime().then(async (runtime) => {
           if (runtimeStartupSettled) {
             await shutdownBridgeAfterFailedStartup(runtime.bridge);
@@ -1546,6 +1742,37 @@ async function runQwenServe(optsIn, deps = {}) {
           runtimeStartupTimer.unref();
         }
       }, "startRuntime");
+      startRuntimeForRequest = startRuntime;
+      const scheduleRuntimeStartFallback = /* @__PURE__ */ __name(() => {
+        if (shuttingDown || runtimeStarting || runtimeStartFallbackTimer)
+          return;
+        daemonLog.info(
+          `deferred runtime: scheduling fallback start in ${FAST_PATH_RUNTIME_START_FALLBACK_MS}ms`
+        );
+        runtimeStartFallbackTimer = setTimeout(() => {
+          runtimeStartFallbackTimer = void 0;
+          if (shuttingDown) return;
+          daemonLog.info("deferred runtime: fallback timer fired, starting");
+          startRuntime();
+        }, FAST_PATH_RUNTIME_START_FALLBACK_MS);
+        runtimeStartFallbackTimer.unref();
+      }, "scheduleRuntimeStartFallback");
+      startRuntimeAfterHealth = /* @__PURE__ */ __name(() => {
+        if (shuttingDown || runtimeStarting || runtimeStartAfterHealthTimer) {
+          return;
+        }
+        clearRuntimeStartFallbackTimer();
+        daemonLog.info(
+          `deferred runtime: health served, scheduling start in ${FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS}ms`
+        );
+        runtimeStartAfterHealthTimer = setTimeout(() => {
+          runtimeStartAfterHealthTimer = void 0;
+          if (shuttingDown) return;
+          daemonLog.info("deferred runtime: health timer fired, starting");
+          startRuntime();
+        }, FAST_PATH_RUNTIME_START_AFTER_HEALTH_MS);
+        runtimeStartAfterHealthTimer.unref();
+      }, "startRuntimeAfterHealth");
       const onSignal = /* @__PURE__ */ __name(async (signal) => {
         if (shuttingDown) {
           daemonLog.warn(`received ${signal} during drain \u2014 forcing exit`);
@@ -1585,6 +1812,9 @@ async function runQwenServe(optsIn, deps = {}) {
           if (closePromise) return closePromise;
           closePromise = new Promise((res, rej) => {
             shuttingDown = true;
+            clearRuntimeStartAfterHealthTimer();
+            clearRuntimeStartFallbackTimer();
+            cancelDeferredRuntimeStartup();
             let settled = false;
             let bridgeShutdownError;
             const finish = /* @__PURE__ */ __name((err) => {
@@ -1688,6 +1918,8 @@ async function runQwenServe(optsIn, deps = {}) {
         if (shouldPreheat) {
           startBridgePreheat(bridgeRef);
         }
+      } else if (deferRuntimeUntilFirstHealth) {
+        scheduleRuntimeStartFallback();
       } else {
         startRuntime();
       }