dsh-opendesign-corouter 0.1.3 → 0.1.5

package/lib/index.js

@@ -1752,8 +1752,8 @@ var CoRouterAdapter = class extends LlmAdapter {
   async *#stream(options, config, row) {
     const signal = AbortSignal.any([combinedSignal(options.signal, config.requestTimeoutMs), this.#lifetime.signal]);
     signal.throwIfAborted();
-    const raw = await this.options.apiKey(config.apiKeyEnv);
-    if (!raw) throw new LlmError10("\u672A\u914D\u7F6E CoRouter API Key\uFF1B\u8BF7\u5728\u63D2\u4EF6\u8BBE\u7F6E\u4E2D\u4FDD\u5B58\u6216\u8BBE\u7F6E\u5BF9\u5E94\u73AF\u5883\u53D8\u91CF", "MISSING_CREDENTIAL");
+    const raw = await this.options.apiKey(config.apiKeyEnv, config.baseURL);
+    if (!raw) throw new LlmError10("\u672A\u914D\u7F6E\u5F53\u524D\u7F51\u5173\u7684\u63A8\u7406\u51ED\u636E\uFF1B\u8BF7\u5B8C\u6210\u8BBE\u5907\u6388\u6743\u6216\u914D\u7F6E\u5BF9\u5E94 API Key", "MISSING_CREDENTIAL");
     const key = assertUsableApiKey(raw, "dsh-opendesign-corouter", config.apiKeyEnv);
     const setting = config.modelSettings?.[row.id] ?? {};
     const protocolId = config.apiProtocol ?? "chat-completions";
@@ -2005,7 +2005,7 @@ function isOfficialApiUrl(raw) {
   if (url.username || url.password) return false;
   if (url.search || url.hash) return false;
   if (url.pathname !== "/" && url.pathname !== "") return false;
-  return url.hostname.toLowerCase() === API_HOST;
+  return url.hostname.toLowerCase() === API_HOST && !url.port;
 }
 function normalizeApiUrl(raw) {
   const value = typeof raw === "string" ? raw.trim() : "";
@@ -2080,6 +2080,24 @@ async function readDesktopCredential(deps = {}) {
   }
   return parseDesktopConfigText(text2, profile);
 }
+function deviceGrant(value) {
+  if (!record(value) || value.kind !== "device" || typeof value.controlKey !== "string" || typeof value.runtimeKey !== "string") return;
+  try {
+    const controlKey = safeSecret(value.controlKey), runtimeKey = safeSecret(value.runtimeKey);
+    if ([controlKey, runtimeKey].some((key) => key.length > 8192 || /\s/u.test(key))) return;
+    return { kind: "device", controlKey, runtimeKey, ...typeof value.savedAt === "string" ? { savedAt: value.savedAt } : {} };
+  } catch {
+    return void 0;
+  }
+}
+function isOfficialRuntimeUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return url.origin === "https://amr-link.open-design.ai" && !url.username && !url.password && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}
 function cookieHeader(raw) {
   const value = raw.trim();
   if (!value || !value.includes("=")) return void 0;
@@ -2100,6 +2118,10 @@ function desktopSession(credential, apiUrl = credential.apiUrl ?? DEFAULT_API_UR
     ...credential.plan ? { plan: credential.plan } : {}
   };
 }
+function deviceSession(tokens) {
+  const controlKey = typeof tokens === "string" ? tokens : tokens.controlKey;
+  return { headers: { authorization: `Bearer ${safeSecret(controlKey)}` }, source: "login", via: "login", apiUrl: DEFAULT_API_URL, credentialType: "device" };
+}
 function cookieSession(cookie, source, apiUrl = DEFAULT_API_URL) {
   const header = cookieHeader(cookie);
   if (!header) return void 0;
@@ -2140,10 +2162,15 @@ async function resolveSession(deps = {}) {
     } catch {
       grant = void 0;
     }
-    const expiry = typeof grant?.expiresAt === "number" && Number.isFinite(grant.expiresAt) ? grant.expiresAt : 0;
-    if (grant && (expiry === 0 || expiry > now())) {
-      const session = cookieSession(grant.cookie, "login");
-      if (session) return { state: "ready", session, warnings };
+    if (grant && "kind" in grant && grant.kind === "device") {
+      const device = deviceGrant(grant);
+      if (device) return { state: "ready", session: deviceSession(device), warnings };
+    } else if (grant && "cookie" in grant) {
+      const expiry = typeof grant.expiresAt === "number" && Number.isFinite(grant.expiresAt) ? grant.expiresAt : 0;
+      if (expiry === 0 || expiry > now()) {
+        const session = cookieSession(grant.cookie, "login");
+        if (session) return { state: "ready", session, warnings };
+      }
     }
   }
   if (deps.resolveRef) {
@@ -2164,61 +2191,207 @@ async function resolveSession(deps = {}) {
 
 // src/login.ts
 import { randomUUID } from "node:crypto";
-var CONSOLE_ORIGIN = "https://open-design.ai";
-var CONSOLE_DASHBOARD_URL = `${CONSOLE_ORIGIN}/cloud/dashboard`;
-var API_COOKIE_URL = "https://amr-api.open-design.ai/api/v1/workspaces/current";
-function extractConsoleSession(cookies, now = Date.now()) {
-  const usable = cookies.filter((c) => typeof c.name === "string" && c.name.length > 0 && typeof c.value === "string" && c.value.length > 0 && (c.expires === void 0 || c.expires === -1 || c.expires * 1e3 > now));
-  if (!usable.length) return null;
-  const declared = usable.map((c) => c.expires).filter((expires) => typeof expires === "number" && Number.isFinite(expires) && expires > 0);
+
+// src/device-auth.ts
+var DEVICE_AUTH_ENDPOINT = "https://amr-api.open-design.ai/api/v1/cli/device-authorizations";
+var DEVICE_AUTH_PLUGIN_VERSION = "0.1.5";
+var DEVICE_REQUEST_TIMEOUT_MS = 2e4;
+var DEVICE_RESPONSE_MAX_BYTES = 65536;
+var DEVICE_POLL_MIN_MS = 1e3;
+var DEVICE_POLL_MAX_MS = 3e5;
+var DeviceAuthError = class extends Error {
+  constructor(code) {
+    super("\u8BBE\u5907\u6388\u6743\u672A\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB");
+    this.code = code;
+  }
+  code;
+};
+function validateActivationUrl(value, userCode) {
+  if (typeof value !== "string" || value.length > 512 || !/^https:\/\/open-design\.ai\/cloud\/cli\/activate(?:\?[^#]*)?$/u.test(value) || /[\s\\]/u.test(value)) return null;
+  try {
+    const url = new URL(value);
+    if (url.origin !== "https://open-design.ai" || url.pathname !== "/cloud/cli/activate" || url.username || url.password || url.hash) return null;
+    const entries = [...url.searchParams];
+    if (entries.length > 1) return null;
+    if (entries.length) {
+      const entry = entries[0];
+      if (!["code", "user_code"].includes(entry[0]) || !validUserCode(entry[1]) || userCode !== void 0 && entry[1] !== userCode) return null;
+    }
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validUserCode(value) {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9-]{3,31}$/iu.test(value);
+}
+function secret(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 8192 && /^[\x21-\x7e]+$/u.test(value);
+}
+function parseDeviceAuthorization(value) {
+  if (!object(value) || typeof value.deviceId !== "string" || !/^[a-z0-9_-]{1,200}$/iu.test(value.deviceId) || !secret(value.deviceSecret) || !validUserCode(value.userCode)) throw new DeviceAuthError("opendesign/login-response");
+  const activationUrl = validateActivationUrl(value.activationUrl, value.userCode);
+  if (!activationUrl || value.userCode.toLowerCase().includes(value.deviceSecret.toLowerCase()) || decodeURIComponent(activationUrl).toLowerCase().includes(value.deviceSecret.toLowerCase())) throw new DeviceAuthError("opendesign/login-response");
+  const expiresAt = typeof value.expiresAt === "string" && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?(?:Z|[+-]\d\d:\d\d)$/u.test(value.expiresAt) ? Date.parse(value.expiresAt) : NaN;
+  if (!Number.isFinite(expiresAt) || typeof value.pollIntervalSeconds !== "number" || !Number.isFinite(value.pollIntervalSeconds) || value.pollIntervalSeconds <= 0) throw new DeviceAuthError("opendesign/login-response");
   return {
-    cookie: usable.map((c) => `${c.name}=${c.value}`).join("; "),
-    expiresAt: declared.length ? Math.min(...declared) * 1e3 : 0
+    deviceId: value.deviceId,
+    deviceSecret: value.deviceSecret,
+    userCode: value.userCode,
+    activationUrl,
+    expiresAt,
+    pollMs: Math.max(DEVICE_POLL_MIN_MS, Math.min(DEVICE_POLL_MAX_MS, value.pollIntervalSeconds * 1e3))
   };
 }
-function consoleSite(overrides = {}) {
-  const origin = overrides.origin ?? CONSOLE_ORIGIN;
-  return {
-    origin,
-    loginUrl: overrides.loginUrl ?? (origin === CONSOLE_ORIGIN ? CONSOLE_DASHBOARD_URL : `${origin}/cloud/dashboard`),
-    cookieUrls: overrides.cookieUrls ?? [API_COOKIE_URL],
-    extract: extractConsoleSession
+function parseDevicePoll(value) {
+  if (!object(value)) throw new DeviceAuthError("opendesign/login-response");
+  const state = typeof value.status === "string" ? value.status.toLowerCase() : "";
+  if (["expired", "cancelled", "canceled", "denied", "rejected", "failed", "error"].includes(state)) throw new DeviceAuthError(state === "expired" ? "opendesign/login-expired" : "opendesign/login-denied");
+  if (value.error !== void 0 && value.error !== null && value.error !== "") throw new DeviceAuthError("opendesign/login-response");
+  const user = object(value.user) ? value.user : {};
+  const topPresent = value.controlKey !== void 0 || value.runtimeKey !== void 0;
+  const source = topPresent ? value : user;
+  if (source.controlKey !== void 0 || source.runtimeKey !== void 0) {
+    if (!secret(source.controlKey) || !secret(source.runtimeKey)) throw new DeviceAuthError("opendesign/login-incomplete");
+    if (topPresent && (user.controlKey !== void 0 && user.controlKey !== source.controlKey || user.runtimeKey !== void 0 && user.runtimeKey !== source.runtimeKey)) throw new DeviceAuthError("opendesign/login-response");
+    return { state: "success", tokens: { controlKey: source.controlKey, runtimeKey: source.runtimeKey } };
+  }
+  if (state === "pending" || state === "authorization_pending") return { state: "pending" };
+  throw new DeviceAuthError("opendesign/login-response");
+}
+function validRequestUrl(value) {
+  return value === DEVICE_AUTH_ENDPOINT || /^https:\/\/amr-api\.open-design\.ai\/api\/v1\/cli\/device-authorizations\/[a-zA-Z0-9_-]{1,200}\/token$/u.test(value);
+}
+async function postDeviceJson(fetcher, url, body, signal, timeoutMs = DEVICE_REQUEST_TIMEOUT_MS) {
+  if (!validRequestUrl(url)) throw new DeviceAuthError("opendesign/login-url");
+  signal.throwIfAborted();
+  const controller = new AbortController();
+  let timedOut = false;
+  let timer;
+  let rejectAbort = () => void 0;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  const cancel = () => {
+    controller.abort();
+    rejectAbort(new DeviceAuthError(timedOut ? "opendesign/login-request-timeout" : "opendesign/login-cancelled"));
   };
+  signal.addEventListener("abort", cancel, { once: true });
+  timer = setTimeout(() => {
+    timedOut = true;
+    cancel();
+  }, Math.max(1, Math.min(DEVICE_REQUEST_TIMEOUT_MS, timeoutMs)));
+  const read = async () => {
+    let response;
+    try {
+      response = await fetcher(url, {
+        method: "POST",
+        redirect: "error",
+        credentials: "omit",
+        referrerPolicy: "no-referrer",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch {
+      throw new DeviceAuthError("opendesign/login-network");
+    }
+    if (controller.signal.aborted) {
+      void response.body?.cancel().catch(() => void 0);
+      throw new DeviceAuthError("opendesign/login-cancelled");
+    }
+    const rejectResponse = (code) => {
+      void response.body?.cancel().catch(() => void 0);
+      throw new DeviceAuthError(code);
+    };
+    if (response.redirected || response.url && response.url !== url || response.status >= 300 && response.status < 400) return rejectResponse("opendesign/login-redirect");
+    if (response.status === 401 || response.status === 403) return rejectResponse("opendesign/login-denied");
+    if (response.status === 404 || response.status === 410) return rejectResponse("opendesign/login-expired");
+    if (!response.ok) return rejectResponse("opendesign/login-network");
+    const declared = response.headers.get("content-length");
+    if (declared !== null && (!/^\d+$/u.test(declared) || Number(declared) > DEVICE_RESPONSE_MAX_BYTES)) return rejectResponse("opendesign/login-response-size");
+    if (!response.body) throw new DeviceAuthError("opendesign/login-response");
+    const reader = response.body.getReader();
+    const stopReading = () => {
+      void reader.cancel().catch(() => void 0);
+    };
+    controller.signal.addEventListener("abort", stopReading, { once: true });
+    const chunks = [];
+    let length = 0;
+    try {
+      for (; ; ) {
+        const part = await reader.read();
+        if (controller.signal.aborted) throw new DeviceAuthError("opendesign/login-cancelled");
+        if (part.done) break;
+        length += part.value.byteLength;
+        if (length > DEVICE_RESPONSE_MAX_BYTES) {
+          stopReading();
+          throw new DeviceAuthError("opendesign/login-response-size");
+        }
+        chunks.push(part.value);
+      }
+      const bytes = new Uint8Array(length);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+      }
+      try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      } catch {
+        throw new DeviceAuthError("opendesign/login-response");
+      }
+    } finally {
+      controller.signal.removeEventListener("abort", stopReading);
+      reader.releaseLock();
+    }
+  };
+  try {
+    return await Promise.race([read(), aborted]);
+  } catch (error) {
+    if (error instanceof DeviceAuthError) throw error;
+    throw new DeviceAuthError("opendesign/login-network");
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    signal.removeEventListener("abort", cancel);
+  }
 }
+
+// src/login.ts
 var LoginError = class extends Error {
   constructor(code) {
-    super(code === "opendesign/login-state" ? "\u767B\u5F55\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u72B6\u6001\u5DF2\u6539\u53D8" : code === "opendesign/login-disposed" ? "\u767B\u5F55\u670D\u52A1\u5DF2\u5378\u8F7D" : "\u65E0\u6CD5\u6355\u83B7\u5F53\u524D\u8BBE\u7F6E\u72B6\u6001\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88");
+    super(code === "opendesign/login-disposed" ? "\u767B\u5F55\u670D\u52A1\u5DF2\u5378\u8F7D" : "\u767B\u5F55\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u72B6\u6001\u5DF2\u6539\u53D8");
     this.code = code;
   }
   code;
 };
 var ACTIVE = /* @__PURE__ */ new Set(["launching", "waiting", "verifying"]);
-var DEFAULT_TIMEOUT_MS = 3e5;
-var DEFAULT_POLL_MS = 1e3;
-var FATAL_COMMIT_CODES = /* @__PURE__ */ new Set(["opendesign/revision-conflict", "opendesign/invalid-request", "opendesign/config", "opendesign/login-disposed"]);
-var CHROME_LAUNCH_OPTIONS = {
-  channel: "chrome",
-  headless: false,
-  ignoreDefaultArgs: ["--enable-automation"],
-  args: ["--disable-blink-features=AutomationControlled"]
-};
+var MAX_TIMEOUT_MS = 3e5;
+var SAFE_HOST_CODES = /* @__PURE__ */ new Set(["opendesign/revision-conflict", "opendesign/invalid-request", "opendesign/config", "opendesign/login-disposed"]);
 var ConsoleLogin = class {
-  job = null;
-  disposed = false;
-  callbacks;
-  options;
-  now;
-  delay;
   constructor(callbacks, options = {}) {
     this.callbacks = callbacks;
     this.options = options;
     this.now = options.now ?? Date.now;
     this.delay = options.delay ?? sleep;
+    this.fetcher = options.fetcher ?? fetch;
   }
-  /** Idempotent, credential-free view of the current attempt. */
+  callbacks;
+  options;
+  job = null;
+  disposed = false;
+  now;
+  delay;
+  fetcher;
+  /** Explicit public allowlist. Codes are never available after waiting or expiry. */
   status() {
     if (!this.job) return { jobId: null, state: "idle" };
-    const s = this.job.status;
+    const job = this.job;
+    if (job.status.state === "waiting" && this.now() >= job.deadline) this.expire(job);
+    const s = job.status;
     return {
       jobId: s.jobId,
       state: s.state,
@@ -2226,241 +2399,450 @@ var ConsoleLogin = class {
       ...s.finishedAt ? { finishedAt: s.finishedAt } : {},
       ...s.message ? { message: s.message } : {},
       ...s.errorCode ? { errorCode: s.errorCode } : {},
-      ...s.browserOpenFailed ? { browserOpenFailed: true } : {}
+      ...s.state === "waiting" && this.now() < job.deadline ? {
+        ...s.activationUrl ? { activationUrl: s.activationUrl } : {},
+        ...s.userCode ? { userCode: s.userCode } : {},
+        ...s.expiresAt ? { expiresAt: s.expiresAt } : {}
+      } : {}
     };
   }
-  /**
-   * Queue one attempt and return immediately: the RPC that starts a login must not wait on a
-   * browser window or on a human. Re-entrant calls while an attempt is live return that
-   * attempt's status instead of opening a second browser.
-   */
+  /** Host-only: the live approval link, so the Host can open it in a bounded window. */
+  activationLink() {
+    const status = this.status();
+    return status.state === "waiting" ? status.activationUrl : void 0;
+  }
+  /** Synchronous/non-blocking and idempotent while capture/network/commit is pending. */
   start(request) {
     if (this.disposed) throw new LoginError("opendesign/login-disposed");
+    this.status();
     if (this.job && ACTIVE.has(this.job.status.state)) return this.status();
+    const started = this.now();
+    const requested = this.options.timeoutMs;
+    const timeoutMs = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(MAX_TIMEOUT_MS, requested) : MAX_TIMEOUT_MS;
     const job = {
       id: randomUUID(),
-      startedAt: new Date(this.now()).toISOString(),
       controller: new AbortController(),
-      expectedRevision: request.expectedRevision,
-      status: { jobId: "", state: "launching", message: "\u6B63\u5728\u6253\u5F00\u4E34\u65F6 Chrome \u767B\u5F55\u7A97\u53E3" },
+      deadline: started + timeoutMs,
+      status: { jobId: null, state: "launching", startedAt: new Date(started).toISOString(), message: "\u6B63\u5728\u7533\u8BF7\u5B98\u65B9\u8BBE\u5907\u6388\u6743\u7801" },
       captured: void 0,
-      capturedAt: void 0,
-      verifying: false,
       committing: false,
-      cancelRequested: false
+      cancelRequested: false,
+      settled: false
     };
     job.status.jobId = job.id;
-    job.status.startedAt = job.startedAt;
     this.job = job;
-    job.timer = setTimeout(() => this.requestCancellation(job, "\u767B\u5F55\u5DF2\u8D85\u8FC7\u4E94\u5206\u949F\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB"), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    job.timer.unref?.();
-    job.capturedAt = Promise.resolve().then(() => this.callbacks.capture(job.expectedRevision)).then((captured) => {
-      job.captured = captured;
-      return captured;
-    });
-    void job.capturedAt.then(() => this.run(job)).catch((error) => {
-      if (this.alive(job)) this.finish(job, "error", "\u767B\u5F55\u65E0\u6CD5\u5F00\u59CB\uFF0C\u8BF7\u91CD\u8BD5", errorCode(error) ?? "opendesign/login-capture");
+    this.armExpiry(job);
+    void Promise.resolve().then(async () => {
+      if (!this.alive(job)) return;
+      try {
+        job.captured = await this.callbacks.capture(request.expectedRevision);
+      } catch (error) {
+        if (this.alive(job)) this.finish(job, "error", "\u65E0\u6CD5\u6355\u83B7\u5F53\u524D\u8BBE\u7F6E\u72B6\u6001\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u91CD\u8BD5", hostCode(error) ?? "opendesign/login-capture");
+        return;
+      }
+      if (this.alive(job)) await this.run(job);
+    }).catch((error) => {
+      if (this.alive(job)) this.finish(job, "error", failureMessage(error), error instanceof DeviceAuthError ? error.code : "opendesign/login-network");
     });
     return this.status();
   }
-  /**
-   * Abandon the attempt. While `commit` is in flight this only aborts the signal and records
-   * the request: the Host's atomic store decides, because the commit is the linearization
-   * point. A cancel that wins that race reports `cancelled`; one that loses reports `success`
-   * and the cookie really is stored.
-   */
   cancel(request) {
-    const job = this.job;
-    if (!job || job.status.jobId !== request.jobId) return this.status();
-    this.requestCancellation(job, "\u767B\u5F55\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FDD\u5B58 Cookie");
+    if (this.job?.id === request.jobId) this.requestCancellation(this.job, "\u767B\u5F55\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FDD\u5B58\u6388\u6743");
     return this.status();
   }
-  /** Plugin teardown: abort the attempt and close the browser. */
   dispose() {
-    const job = this.job;
-    if (job) this.requestCancellation(job, "\u670D\u52A1\u5DF2\u5378\u8F7D\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88");
     this.disposed = true;
+    const job = this.job;
+    if (job) {
+      this.requestCancellation(job, "\u670D\u52A1\u5DF2\u5378\u8F7D\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88");
+      this.settle(job);
+    }
+  }
+  alive(job) {
+    return this.job === job && !this.disposed && !job.controller.signal.aborted && ACTIVE.has(job.status.state);
+  }
+  stopTimer(job) {
+    if (job.timer !== void 0) {
+      clearTimeout(job.timer);
+      job.timer = void 0;
+    }
+  }
+  armExpiry(job) {
+    this.stopTimer(job);
+    job.timer = setTimeout(() => this.expire(job), Math.max(1, job.deadline - this.now()));
+    job.timer.unref?.();
+  }
+  clearCode(job) {
+    delete job.status.activationUrl;
+    delete job.status.userCode;
+    delete job.status.expiresAt;
+  }
+  expire(job) {
+    if (job.committing) this.requestCancellation(job, "\u6388\u6743\u5DF2\u8FC7\u671F\uFF0C\u672A\u4FDD\u5B58\u6388\u6743");
+    else this.finish(job, "error", "\u8BBE\u5907\u6388\u6743\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB", "opendesign/login-expired");
   }
-  /** Every cancellation source must let an in-flight atomic store decide the final outcome. */
   requestCancellation(job, message) {
     if (this.job !== job || !ACTIVE.has(job.status.state)) return;
+    this.clearCode(job);
     if (!job.committing) {
       this.finish(job, "cancelled", message);
       return;
     }
     if (!job.cancelRequested) {
       job.cancellationMessage = message;
-      job.status.message = "\u6B63\u5728\u786E\u8BA4\u4F1A\u8BDD\u4FDD\u5B58\u7ED3\u679C";
+      job.status.message = "\u6B63\u5728\u786E\u8BA4\u6388\u6743\u4FDD\u5B58\u7ED3\u679C";
     }
     job.cancelRequested = true;
     this.stopTimer(job);
     job.controller.abort();
-    void this.close(job);
-  }
-  alive(job) {
-    if (this.disposed || this.job !== job) return false;
-    if (job.controller.signal.aborted && !job.committing) return false;
-    return job.status.state !== "success" && job.status.state !== "cancelled" && job.status.state !== "error";
-  }
-  stopTimer(job) {
-    if (job.timer) {
-      clearTimeout(job.timer);
-      job.timer = void 0;
-    }
   }
-  async close(job) {
-    const browser = job.browser;
-    job.browser = void 0;
-    try {
-      await browser?.close();
-    } catch {
-    }
-  }
-  finish(job, state, message, errorCode2) {
-    if (this.job !== job) return;
-    if (job.status.state === "success" || job.status.state === "cancelled" || job.status.state === "error") return;
+  finish(job, state, message, errorCode) {
+    if (this.job !== job || !ACTIVE.has(job.status.state)) return;
     job.status.state = state;
     job.status.finishedAt = new Date(this.now()).toISOString();
     job.status.message = message;
-    if (errorCode2) job.status.errorCode = errorCode2;
-    job.secret = void 0;
+    if (errorCode) job.status.errorCode = errorCode;
+    this.clearCode(job);
     this.stopTimer(job);
     job.controller.abort();
-    void this.close(job);
+    this.settle(job);
   }
-  async resolveBrowser(job) {
-    if (!this.alive(job)) return null;
-    const launch = this.options.launch ?? defaultLaunch;
-    const browser = await launch(job.controller.signal);
-    if (!browser) return null;
-    job.browser = browser;
-    browser.on?.("disconnected", () => this.requestCancellation(job, "\u767B\u5F55\u7A97\u53E3\u5DF2\u5173\u95ED\uFF0C\u672A\u4FDD\u5B58 Cookie"));
-    return browser;
-  }
-  async run(job) {
-    const site = this.options.site ?? consoleSite();
-    const browser = await this.resolveBrowser(job);
-    if (!browser) return;
-    if (!this.alive(job)) {
-      await this.close(job);
-      return;
-    }
-    const context = await browser.newContext();
-    if (!this.alive(job)) {
-      await this.close(job);
-      return;
-    }
-    const page = await context.newPage();
-    page.on?.("close", () => this.requestCancellation(job, "\u767B\u5F55\u7A97\u53E3\u5DF2\u5173\u95ED\uFF0C\u672A\u4FDD\u5B58 Cookie"));
-    if (!this.alive(job)) {
-      await this.close(job);
-      return;
-    }
+  /** Report one terminal transition per job, exactly once. */
+  settle(job) {
+    if (job.settled) return;
+    job.settled = true;
     try {
-      await page.goto(site.loginUrl, { waitUntil: "domcontentloaded", timeout: 3e4 });
+      this.options.onSettled?.();
     } catch {
-      if (!this.alive(job)) return;
-      try {
-        await page.goto(site.origin, { waitUntil: "domcontentloaded", timeout: 3e4 });
-      } catch {
-        job.status.browserOpenFailed = true;
-      }
     }
+  }
+  async run(job) {
+    const signal = job.controller.signal;
+    const raw = await postDeviceJson(this.fetcher, DEVICE_AUTH_ENDPOINT, {
+      // The third-party protocol's official-CLI version is NOT our version. Compatibility
+      // of this actual plugin version requires a real-account check outside offline tests.
+      cliVersion: DEVICE_AUTH_PLUGIN_VERSION,
+      host: "DSH CoRouter",
+      profile: "prod"
+    }, signal, job.deadline - this.now());
     if (!this.alive(job)) return;
+    const device = parseDeviceAuthorization(raw);
+    job.deadline = Math.min(job.deadline, device.expiresAt);
+    if (this.now() >= job.deadline) {
+      this.expire(job);
+      return;
+    }
+    this.armExpiry(job);
     job.status.state = "waiting";
-    job.status.message = "\u8BF7\u5728\u5B98\u65B9\u7A97\u53E3\u81EA\u884C\u5B8C\u6210\u767B\u5F55\uFF1B\u8D26\u6237\u9A8C\u8BC1\u901A\u8FC7\u540E\u4FDD\u5B58\uFF0C\u989D\u5EA6\u72B6\u6001\u53E6\u884C\u663E\u793A";
-    let nextAttempt = 0;
-    let failures = 0;
-    const pollMs = this.options.pollMs ?? DEFAULT_POLL_MS;
+    job.status.message = "\u8BF7\u5728\u6388\u6743\u7A97\u53E3\u6216\u5E38\u7528\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u65B9\u6388\u6743\u9875\uFF0C\u767B\u5F55\u5E76\u786E\u8BA4\u8BBE\u5907\u7801";
+    job.status.activationUrl = device.activationUrl;
+    job.status.userCode = device.userCode;
+    job.status.expiresAt = new Date(job.deadline).toISOString();
     while (this.alive(job)) {
-      if (!job.verifying) {
-        const session = site.extract(await context.cookies(site.cookieUrls), this.now());
-        if (!this.alive(job)) return;
-        if (session && this.now() >= nextAttempt) {
-          job.verifying = true;
-          job.status.state = "verifying";
-          job.status.message = "\u6B63\u5728\u9A8C\u8BC1\u767B\u5F55\u548C\u8BA2\u9605\u989D\u5EA6\uFF08\u5C1A\u672A\u4FDD\u5B58\uFF09";
-          try {
-            const verified = await this.callbacks.verify(session.cookie, job.controller.signal);
-            if (!this.alive(job)) return;
-            if (verified.usageError || !verified.balanceOk) {
-              job.status.state = "waiting";
-              job.status.message = "\u5DF2\u8BFB\u53D6\u8D26\u6237\uFF0C\u4F46\u8BA2\u9605\u989D\u5EA6\u5C1A\u672A\u5B8C\u6574\u9A8C\u8BC1\uFF1B\u5C1A\u672A\u4FDD\u5B58\uFF0C\u8BF7\u786E\u8BA4\u5957\u9910\u6216\u7EE7\u7EED\u767B\u5F55";
-              nextAttempt = this.now() + 15e3;
-            } else {
-              const outcome = await this.commit(job, session);
-              if (outcome !== "retry") return;
-              failures += 1;
-              nextAttempt = this.now() + Math.max(5e3, Math.min(6e4, 2e3 * 2 ** Math.min(failures, 5)));
-            }
-          } catch (error) {
-            if (!this.alive(job)) return;
-            failures += 1;
-            nextAttempt = this.now() + Math.max(5e3, Math.min(6e4, 2e3 * 2 ** Math.min(failures, 5)), retryAfterMs(error));
-            job.status.state = "waiting";
-            job.status.message = errorCode(error) === "opendesign/auth" ? "\u767B\u5F55\u5C1A\u672A\u751F\u6548\uFF0C\u8BF7\u7EE7\u7EED\u5728\u5B98\u65B9\u7A97\u53E3\u5B8C\u6210\u767B\u5F55\uFF1B\u672A\u4FDD\u5B58" : "\u989D\u5EA6\u9A8C\u8BC1\u6682\u672A\u6210\u529F\uFF0C\u5C06\u9650\u9891\u91CD\u8BD5\uFF1B\u672A\u4FDD\u5B58";
-          } finally {
-            job.verifying = false;
-          }
-        }
+      await this.delay(Math.min(device.pollMs, Math.max(1, job.deadline - this.now())), signal);
+      if (!this.alive(job)) return;
+      if (this.now() >= job.deadline) {
+        this.expire(job);
+        return;
+      }
+      const result = parseDevicePoll(await postDeviceJson(
+        this.fetcher,
+        `${DEVICE_AUTH_ENDPOINT}/${device.deviceId}/token`,
+        { deviceSecret: device.deviceSecret },
+        signal,
+        job.deadline - this.now()
+      ));
+      if (!this.alive(job)) return;
+      if (this.now() >= job.deadline) {
+        this.expire(job);
+        return;
+      }
+      if (result.state === "success") {
+        await this.commit(job, result.tokens);
+        return;
       }
-      await this.delay(pollMs, job.controller.signal);
     }
   }
-  /**
-   * Persist the verified session; `commit` resolving is the linearization point. Returns
-   * `retry` when the store rejected the write transiently, so the caller decides when to try
-   * again instead of claiming a success that did not happen.
-   */
-  async commit(job, session) {
-    if (job.committing || !this.alive(job)) return "cancelled";
+  async commit(job, tokens) {
+    if (!this.alive(job) || job.committing) return;
     job.committing = true;
+    this.clearCode(job);
     job.status.state = "verifying";
-    job.status.message = "\u767B\u5F55\u5DF2\u9A8C\u8BC1\uFF0C\u6B63\u5728\u4FDD\u5B58\u4F1A\u8BDD";
+    job.status.message = "\u5B98\u65B9\u6388\u6743\u5DF2\u5B8C\u6210\uFF0C\u6B63\u5728\u4FDD\u5B58\u6388\u6743";
     try {
-      await this.callbacks.commit(session.cookie, job.captured, job.controller.signal, session.expiresAt);
+      await this.callbacks.commit(tokens, job.captured, job.controller.signal);
       job.committing = false;
-      this.finish(job, "success", "\u767B\u5F55\u53CA\u8BA2\u9605\u989D\u5EA6\u5DF2\u9A8C\u8BC1\uFF0CCookie \u5DF2\u4FDD\u5B58");
-      return "success";
+      this.finish(job, "success", "\u8BBE\u5907\u6388\u6743\u5DF2\u5B8C\u6210\u5E76\u4FDD\u5B58\uFF1B\u989D\u5EA6\u72B6\u6001\u53E6\u884C\u663E\u793A");
     } catch (error) {
       job.committing = false;
-      if (job.cancelRequested || job.controller.signal.aborted) {
-        this.finish(job, "cancelled", job.cancellationMessage ?? "\u767B\u5F55\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FDD\u5B58 Cookie");
-        return "cancelled";
-      }
-      if (FATAL_COMMIT_CODES.has(errorCode(error) ?? "")) {
-        this.finish(job, "error", "\u8BBE\u7F6E\u5DF2\u6539\u53D8\u6216\u65E0\u6CD5\u4FDD\u5B58\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u91CD\u8BD5", errorCode(error));
-        return "error";
-      }
-      job.status.state = "waiting";
-      job.status.message = "\u767B\u5F55\u5DF2\u9A8C\u8BC1\uFF0C\u4F46\u4FDD\u5B58\u6682\u672A\u6210\u529F\uFF0C\u5C06\u9650\u9891\u91CD\u8BD5\uFF1B\u5C1A\u672A\u4FDD\u5B58";
-      return "retry";
+      if (job.cancelRequested || job.controller.signal.aborted) this.finish(job, "cancelled", job.cancellationMessage ?? "\u767B\u5F55\u5DF2\u53D6\u6D88\uFF0C\u672A\u4FDD\u5B58\u6388\u6743");
+      else this.finish(job, "error", hostCode(error) ? "\u8BBE\u7F6E\u5DF2\u6539\u53D8\u6216\u65E0\u6CD5\u4FDD\u5B58\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u91CD\u8BD5" : "\u6388\u6743\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB", hostCode(error) ?? "opendesign/login-commit");
     }
   }
 };
-function errorCode(error) {
-  if (error && typeof error === "object" && "code" in error && typeof error.code === "string") return error.code;
+function hostCode(error) {
+  if (error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" && SAFE_HOST_CODES.has(error.code)) return error.code;
   return void 0;
 }
-function retryAfterMs(error) {
-  if (!error || typeof error !== "object") return 0;
-  const details = error.details;
-  if (!details || typeof details !== "object") return 0;
-  const value = details.retryAfterMs;
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.min(3e5, value) : 0;
-}
-async function defaultLaunch(signal) {
-  if (signal.aborted) return null;
-  const { chromium } = await import("playwright-core");
-  if (signal.aborted) return null;
-  return await chromium.launch({
-    channel: CHROME_LAUNCH_OPTIONS.channel,
-    headless: CHROME_LAUNCH_OPTIONS.headless,
-    // Copied so Playwright, which wants mutable arrays, cannot freeze on the readonly literals.
-    ignoreDefaultArgs: [...CHROME_LAUNCH_OPTIONS.ignoreDefaultArgs],
-    args: [...CHROME_LAUNCH_OPTIONS.args]
+function failureMessage(error) {
+  const code = error instanceof DeviceAuthError ? error.code : "";
+  if (code === "opendesign/login-expired") return "\u8BBE\u5907\u6388\u6743\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB";
+  if (code === "opendesign/login-denied") return "\u8BBE\u5907\u6388\u6743\u88AB\u62D2\u7EDD\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB";
+  if (code === "opendesign/login-request-timeout") return "\u8BBE\u5907\u6388\u6743\u8BF7\u6C42\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB";
+  return "\u8BBE\u5907\u6388\u6743\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB";
+}
+
+// src/browser-open.ts
+var ACTIVATION_NAVIGATE_TIMEOUT_MS = 15e3;
+var ACTIVATION_OPEN_BUDGET_MS = 2e4;
+var ACTIVATION_CLOSE_TIMEOUT_MS = 5e3;
+function chromeLaunchOptions() {
+  return {
+    channel: "chrome",
+    headless: false,
+    chromiumSandbox: true,
+    ignoreDefaultArgs: ["--enable-automation"],
+    args: ["--disable-blink-features=AutomationControlled"]
+  };
+}
+var ActivationLauncher = class {
+  browser;
+  page;
+  pending;
+  disposal;
+  /** In-flight window closure, shared so disposal can join it. */
+  closing;
+  /** Closures of handles that were never adopted; disposal joins them too. */
+  tracked = [];
+  /** Chrome starts in flight, so disposal waits for the handle they will produce. */
+  starting = [];
+  disposed = false;
+  /** Bumped by `close()`: an attempt from an older session must not resurrect a window. */
+  session = 0;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Show `url` in the temporary window, reusing one already open. Concurrent calls share
+   * a single attempt: the caller's button stays honest about what actually happened.
+   */
+  async open(url) {
+    if (validateActivationUrl(url) === null) return { code: "invalid-url", opened: false };
+    if (this.disposed) return { code: "failed", opened: false };
+    if (this.pending) return this.pending;
+    const attempt = this.attempt(url);
+    this.pending = attempt;
+    try {
+      return await attempt;
+    } finally {
+      if (this.pending === attempt) this.pending = void 0;
+    }
+  }
+  /**
+   * Close the temporary window and stay usable: a cancelled or expired job takes its
+   * window away, while the next login may open a new one.
+   */
+  async close() {
+    this.session++;
+    await this.closeCurrent();
+  }
+  /**
+   * Retire the launcher for good. Cleanup is best-effort and bounded: it joins in-flight
+   * starts and closures, but a browser that ignores `close()` may outlive the 5 s wait.
+   */
+  async dispose() {
+    this.disposed = true;
+    this.session++;
+    if (this.disposal) return this.disposal;
+    this.disposal = (async () => {
+      await this.bounded(Date.now() + ACTIVATION_CLOSE_TIMEOUT_MS, async () => {
+        await Promise.allSettled(this.starting);
+      });
+      await this.closing;
+      await this.closeCurrent();
+      await this.bounded(Date.now() + ACTIVATION_CLOSE_TIMEOUT_MS, async () => {
+        await Promise.all(this.tracked);
+      });
+    })();
+    return this.disposal;
+  }
+  /**
+   * Close the window this launcher owns right now. Ownership is taken before the async
+   * close, so a job that adopts a new window afterwards is not affected by this closure.
+   * The closure promise is shared so a later `dispose()` joins it.
+   */
+  async closeCurrent() {
+    if (this.closing === void 0) {
+      const browser = this.browser;
+      this.browser = void 0;
+      this.page = void 0;
+      if (browser === void 0) return;
+      this.closing = closeBounded(browser);
+    }
+    const closing = this.closing;
+    try {
+      await closing;
+    } finally {
+      if (this.closing === closing) this.closing = void 0;
+    }
+  }
+  async attempt(url) {
+    const session = this.session;
+    const budget = this.options.timeoutMs ?? ACTIVATION_OPEN_BUDGET_MS;
+    const deadline = Date.now() + budget;
+    try {
+      if (this.options.available?.() === false) return { code: "unavailable", opened: false };
+      const browser = await this.ensureBrowser(session, deadline);
+      if (browser === void 0) return { code: this.stale(session) ? "failed" : "unavailable", opened: false };
+      if (this.stale(session)) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      const page = await this.ensurePage(browser, session, deadline);
+      if (page === void 0) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      const remaining = Math.max(1, Math.min(ACTIVATION_NAVIGATE_TIMEOUT_MS, deadline - Date.now()));
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: remaining });
+      if (this.stale(session)) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      return { code: "opened", opened: true };
+    } catch {
+      await this.bounded(deadline, () => this.closeCurrent());
+      return { code: "failed", opened: false };
+    }
+  }
+  /** The job that started this attempt ended, or the launcher retired. */
+  stale(session) {
+    return this.disposed || session !== this.session;
+  }
+  async ensureBrowser(session, deadline) {
+    const open = this.browser;
+    if (open !== void 0) {
+      try {
+        if (open.isConnected()) return open;
+      } catch {
+      }
+      await this.bounded(deadline, () => this.closeCurrent());
+    }
+    for (let round = 0; round < 2; round++) {
+      await this.bounded(deadline, async () => {
+        await Promise.allSettled([this.closing, ...this.tracked, ...this.starting]);
+      });
+      if (this.stale(session) || Date.now() >= deadline) return void 0;
+      if (this.closing === void 0 && this.tracked.length === 0 && this.starting.length === 0) break;
+    }
+    if (this.stale(session) || Date.now() >= deadline) return void 0;
+    const launch = this.options.launch ?? defaultLaunch;
+    const starting = launch();
+    this.starting.push(starting);
+    const browser = await this.bounded(deadline, () => starting);
+    void starting.then((handle) => {
+      if (handle !== browser) void this.trackClose(handle);
+    }).catch(() => void 0).finally(() => {
+      this.starting = this.starting.filter((item) => item !== starting);
+    });
+    if (browser === void 0) return void 0;
+    if (this.stale(session)) {
+      void this.trackClose(browser);
+      return void 0;
+    }
+    this.adopt(browser);
+    return browser;
+  }
+  async ensurePage(browser, session, deadline) {
+    if (this.page !== void 0) return this.page;
+    const page = await this.bounded(deadline, () => browser.newPage(), (late) => {
+      void this.trackPageClose(late);
+    });
+    if (page === void 0) return void 0;
+    if (this.stale(session) || this.browser !== browser) {
+      await this.bounded(deadline, () => this.closeCurrent());
+      return void 0;
+    }
+    this.page = page;
+    return page;
+  }
+  /** A handle that arrived too late is closed, and still counts as work disposal joins. */
+  trackClose(browser) {
+    const closing = closeBounded(browser);
+    this.tracked.push(closing);
+    void closing.finally(() => {
+      this.tracked = this.tracked.filter((item) => item !== closing);
+    });
+    return closing;
+  }
+  trackPageClose(page) {
+    try {
+      return Promise.resolve(page.close?.()).catch(() => void 0);
+    } catch {
+      return Promise.resolve();
+    }
+  }
+  adopt(browser) {
+    this.browser = browser;
+    browser.on?.("disconnected", () => {
+      if (this.browser === browser) {
+        this.browser = void 0;
+        this.page = void 0;
+      }
+    });
+  }
+  /**
+   * Bound one launch step by the attempt's shared deadline. A step that settles only
+   * after that deadline still hands its handle back: dropping it would leak a Chrome
+   * process nobody can close.
+   */
+  async bounded(deadline, start, discardOnLate) {
+    let timer;
+    let expired = false;
+    const work = (async () => {
+      try {
+        return await start();
+      } catch {
+        return void 0;
+      }
+    })().then((value) => {
+      if (expired && value !== void 0) discardOnLate?.(value);
+      return value;
+    });
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        expired = true;
+        resolve(void 0);
+      }, Math.max(1, deadline - Date.now()));
+    });
+    try {
+      return await Promise.race([work, timeout]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+};
+function closeBounded(browser) {
+  let timer;
+  return Promise.race([
+    (async () => {
+      try {
+        await browser.close();
+      } catch {
+      }
+    })(),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, ACTIVATION_CLOSE_TIMEOUT_MS);
+    })
+  ]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
   });
 }
+async function defaultLaunch() {
+  const playwright = await import("playwright-core");
+  return playwright.chromium.launch(chromeLaunchOptions());
+}
 
 // src/quota.ts
 import { attributionHeaders as attributionHeaders3 } from "@deepseek-ai/dsh-llm";
@@ -2468,6 +2850,7 @@ var API_BASE = "https://amr-api.open-design.ai/api/v1";
 var CURRENT_URL = `${API_BASE}/workspaces/current`;
 var SUMMARY_URL = `${API_BASE}/billing/summary`;
 var usageUrl = (workspace) => `${API_BASE}/workspaces/${encodeURIComponent(workspace)}/billing/coding-plan-usage`;
+var preflightUrl = (workspace) => `${API_BASE}/workspaces/${encodeURIComponent(workspace)}/billing/preflight`;
 var ConsoleError = class extends Error {
   constructor(kind, status) {
     super(kind === "auth" ? "OpenDesign \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" : kind === "permission" ? "OpenDesign \u5F53\u524D\u767B\u5F55\u6001\u65E0\u6743\u8BFB\u53D6\u8BE5\u989D\u5EA6\u5C42" : kind === "rate-limit" ? "OpenDesign \u989D\u5EA6\u63A5\u53E3\u9650\u6D41\uFF0C\u8BF7\u7A0D\u540E\u5237\u65B0" : kind === "response" ? "OpenDesign \u989D\u5EA6\u63A5\u53E3\u8FD4\u56DE\u683C\u5F0F\u53D1\u751F\u53D8\u5316" : "OpenDesign \u989D\u5EA6\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6");
@@ -2478,46 +2861,90 @@ var ConsoleError = class extends Error {
   status;
 };
 async function consoleJson(url, session, signal, fetcher = fetch) {
-  let response;
-  try {
-    response = await fetcher(url, { headers: { ...attributionHeaders3(), accept: "application/json", ...session.headers }, signal: combinedSignal(signal, 2e4), redirect: "error" });
-  } catch {
-    throw new ConsoleError("network");
-  }
-  if (response.status === 401 || response.status === 403) {
-    await response.body?.cancel();
-    throw new ConsoleError(response.status === 401 ? "auth" : "permission", response.status);
-  }
-  if (!response.ok) {
-    await response.body?.cancel();
-    throw new ConsoleError(response.status === 429 ? "rate-limit" : "network", response.status);
-  }
-  const reader = response.body?.getReader();
-  if (!reader) throw new ConsoleError("response");
-  let size = 0, raw = "";
-  const decoder = new TextDecoder();
-  try {
-    while (true) {
-      const chunk = await reader.read();
-      if (chunk.done) break;
-      size += chunk.value.byteLength;
-      if (size > 2 * 1024 * 1024) throw new ConsoleError("response");
-      raw += decoder.decode(chunk.value, { stream: true });
+  signal?.throwIfAborted();
+  if (session.credentialType === "device") {
+    let target;
+    try {
+      target = new URL(url);
+    } catch {
+      throw new ConsoleError("response");
     }
-    raw += decoder.decode();
-  } finally {
-    await reader.cancel().catch(() => void 0);
-    reader.releaseLock();
+    if (target.origin !== "https://amr-api.open-design.ai" || target.username || target.password) throw new ConsoleError("response");
   }
-  let body;
+  const requestSignal = combinedSignal(signal, 2e4);
+  let rejectAbort = () => void 0;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => rejectAbort(new ConsoleError("network"));
+  requestSignal.addEventListener("abort", onAbort, { once: true });
+  const read = async () => {
+    const response = await fetcher(url, { headers: { ...attributionHeaders3(), accept: "application/json", ...session.headers }, signal: requestSignal, redirect: "error", credentials: "omit" });
+    const cancelBody = () => {
+      void response.body?.cancel().catch(() => void 0);
+    };
+    if (requestSignal.aborted) {
+      cancelBody();
+      throw new ConsoleError("network");
+    }
+    if (response.redirected || response.url && response.url !== url) {
+      cancelBody();
+      throw new ConsoleError("response");
+    }
+    if (response.status === 401 || response.status === 403) {
+      cancelBody();
+      throw new ConsoleError(response.status === 401 ? "auth" : "permission", response.status);
+    }
+    if (!response.ok) {
+      cancelBody();
+      throw new ConsoleError(response.status === 429 ? "rate-limit" : "network", response.status);
+    }
+    const declared = response.headers.get("content-length");
+    if (declared !== null && (!/^\d+$/u.test(declared) || Number(declared) > 2 * 1024 * 1024)) {
+      cancelBody();
+      throw new ConsoleError("response");
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new ConsoleError("response");
+    const cancelReader = () => {
+      void reader.cancel().catch(() => void 0);
+    };
+    requestSignal.addEventListener("abort", cancelReader, { once: true });
+    let size = 0, raw = "";
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (requestSignal.aborted) throw new ConsoleError("network");
+        if (chunk.done) break;
+        size += chunk.value.byteLength;
+        if (size > 2 * 1024 * 1024) throw new ConsoleError("response");
+        raw += decoder.decode(chunk.value, { stream: true });
+      }
+      raw += decoder.decode();
+    } finally {
+      requestSignal.removeEventListener("abort", cancelReader);
+      cancelReader();
+      reader.releaseLock();
+    }
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      throw new ConsoleError("response");
+    }
+    if (record(body) && (body.code === 401 || body.code === "401")) throw new ConsoleError("auth", 401);
+    if (record(body) && (body.code === 403 || body.code === "403")) throw new ConsoleError("permission", 403);
+    return body;
+  };
   try {
-    body = JSON.parse(raw);
-  } catch {
-    throw new ConsoleError("response");
+    return await Promise.race([read(), aborted]);
+  } catch (error) {
+    signal?.throwIfAborted();
+    throw error instanceof ConsoleError ? error : new ConsoleError("network");
+  } finally {
+    requestSignal.removeEventListener("abort", onAbort);
   }
-  if (record(body) && (body.code === 401 || body.code === "401")) throw new ConsoleError("auth", 401);
-  if (record(body) && (body.code === 403 || body.code === "403")) throw new ConsoleError("permission", 403);
-  return body;
 }
 function number(value, negative = false) {
   const n = typeof value === "number" ? value : typeof value === "string" && /^-?\d+(\.\d+)?$/u.test(value.trim()) ? Number(value) : NaN;
@@ -2555,7 +2982,51 @@ function normalizeBalances(summary) {
   const totalUsd = number(summary.balanceUsd, true) ?? number(summary.totalAvailableCreditsUsd, true) ?? (divisor !== void 0 && total !== void 0 ? total / divisor : void 0);
   return { ...divisor !== void 0 && subscription !== void 0 ? { subscriptionUsd: subscription / divisor } : {}, ...divisor !== void 0 && recharge !== void 0 ? { rechargeUsd: recharge / divisor } : {}, ...totalUsd !== void 0 ? { totalUsd } : {} };
 }
+async function readDeviceQuota(session, signal, fetcher = fetch) {
+  const common = { source: session.source, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  let current;
+  try {
+    current = await consoleJson(CURRENT_URL, session, signal, fetcher);
+  } catch (error) {
+    signal?.throwIfAborted();
+    if (error instanceof ConsoleError && error.kind === "permission") return { ...common, state: "partial", windows: [], balances: {}, note: "\u5F53\u524D\u8BBE\u5907\u6388\u6743\u65E0\u6743\u8BFB\u53D6\u5DE5\u4F5C\u533A\uFF1B\u989D\u5EA6\u6682\u4E0D\u53EF\u786E\u8BA4" };
+    throw error;
+  }
+  if (!record(current)) throw new ConsoleError("response");
+  const workspaceId = typeof current.activeWorkspaceId === "string" && current.activeWorkspaceId.trim() ? current.activeWorkspaceId : current.workspaceId;
+  if (typeof workspaceId !== "string" || !/^[A-Za-z0-9_-]{1,64}$/u.test(workspaceId)) throw new ConsoleError("response");
+  const personal = current.workspaceType === "personal";
+  const [preflight, billing] = await Promise.allSettled([
+    consoleJson(preflightUrl(workspaceId), session, signal, fetcher),
+    personal ? consoleJson(SUMMARY_URL, session, signal, fetcher) : Promise.resolve(void 0)
+  ]);
+  signal?.throwIfAborted();
+  for (const item of [preflight, billing]) if (item.status === "rejected" && item.reason instanceof ConsoleError && item.reason.kind === "auth") throw item.reason;
+  const summary = billing.status === "fulfilled" ? billing.value : void 0;
+  const flight = preflight.status === "fulfilled" && record(preflight.value) ? preflight.value : void 0;
+  let normalized;
+  try {
+    normalized = normalizeQuota(flight?.codingPlan, personal ? summary : void 0);
+  } catch (error) {
+    if (!(error instanceof ConsoleError)) throw error;
+  }
+  const balances = personal ? normalizeBalances(summary) : {};
+  const total = personal ? number(flight?.balanceUsd, true) : void 0;
+  if (total !== void 0) balances.totalUsd = total;
+  const permission = [preflight, billing].some((item) => item.status === "rejected" && item.reason instanceof ConsoleError && item.reason.kind === "permission");
+  if (!normalized && !Object.keys(balances).length && !permission) {
+    if (preflight.status === "rejected") throw preflight.reason;
+    throw new ConsoleError("response");
+  }
+  const windows = normalized?.windows ?? [];
+  const missingWindows = normalized?.eligible !== false && !windows.length;
+  const missingBalances = personal && Object.keys(balances).length < 3;
+  const partial = missingWindows || missingBalances || !personal || permission;
+  const note = !personal ? "\u56E2\u961F\u6216\u672A\u77E5\u5DE5\u4F5C\u533A\uFF1A\u8D26\u53F7\u94B1\u5305\u53E3\u5F84\u672A\u6838\u5B9E\uFF0C\u6682\u4E0D\u663E\u793A" : missingWindows ? "\u5957\u9910\u989D\u5EA6\u7A97\u53E3\u6682\u4E0D\u53EF\u786E\u8BA4" : missingBalances ? "\u90E8\u5206\u94B1\u5305\u4F59\u989D\u6682\u4E0D\u53EF\u786E\u8BA4" : permission ? "\u90E8\u5206\u989D\u5EA6\u5C42\u65E0\u6743\u8BFB\u53D6" : normalized?.eligible === false ? "\u8BE5\u8D26\u53F7\u6CA1\u6709 Design Plan \u8BA2\u9605\uFF1B\u94B1\u5305\u4F59\u989D\u7167\u5E38\u663E\u793A" : void 0;
+  return { ...common, ...normalized, ...normalizeSubscription(personal ? summary : void 0), windows, balances, state: partial ? "partial" : "ok", ...note ? { note } : {} };
+}
 async function readQuota(session, signal, fetcher = fetch) {
+  if (session.credentialType === "device") return readDeviceQuota(session, signal, fetcher);
   const current = await consoleJson(CURRENT_URL, session, signal, fetcher);
   if (!record(current) || typeof current.workspaceId !== "string" || !/^[A-Za-z0-9_-]{1,64}$/u.test(current.workspaceId)) throw new ConsoleError("response");
   const personal = current.workspaceType === "personal";
@@ -2660,6 +3131,7 @@ var MAX_API_KEY = 16384;
 var HTTP_ASCII = /^[\x21-\x7e]+$/u;
 var ENV_REF = /^[A-Za-z_][A-Za-z0-9_]*$/u;
 var MODEL_ID2 = /^[A-Za-z0-9._:/-]{1,128}$/u;
+var ACTIVATION_OPEN_CODES = ["opened", "no-link", "invalid-url", "unavailable", "failed"];
 var LOGIN_PHASES = ["idle", "launching", "waiting", "verifying", "success", "cancelled", "error"];
 var QUOTA_STATES = ["ok", "partial", "need-login", "error"];
 var SESSION_SOURCES = ["desktop", "login", "environment"];
@@ -2747,9 +3219,19 @@ function parseLoginState(value) {
   if (!record(value)) throw new Error("\u767B\u5F55\u72B6\u6001\u5FC5\u987B\u662F\u5BF9\u8C61");
   const jobId = value.jobId;
   if (jobId !== null && jobId !== void 0 && typeof jobId !== "string") throw new Error("\u767B\u5F55\u4EFB\u52A1 id \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216 null");
+  const state = member(value.state, LOGIN_PHASES, "\u767B\u5F55\u9636\u6BB5");
+  let approval = {};
+  if (state === "waiting" && (value.activationUrl !== void 0 || value.userCode !== void 0 || value.expiresAt !== void 0)) {
+    const userCode = text(value.userCode, "\u8BBE\u5907\u6388\u6743\u7801", 64);
+    if (!/^[A-Za-z0-9-]+$/u.test(userCode)) throw new Error("\u8BBE\u5907\u6388\u6743\u7801\u683C\u5F0F\u65E0\u6548");
+    const activationUrl = validateActivationUrl(value.activationUrl, userCode);
+    if (activationUrl === null) throw new Error("\u8BBE\u5907\u6388\u6743\u94FE\u63A5\u65E0\u6548");
+    approval = { activationUrl, userCode, expiresAt: isoTime(value.expiresAt, "\u8BBE\u5907\u6388\u6743\u5230\u671F\u65F6\u95F4") };
+  }
   return {
     jobId: typeof jobId === "string" && jobId.length > 0 ? text(jobId, "\u767B\u5F55\u4EFB\u52A1 id", MAX_JOB_ID) : null,
-    state: member(value.state, LOGIN_PHASES, "\u767B\u5F55\u9636\u6BB5"),
+    state,
+    ...approval,
     ...value.message === void 0 ? {} : { message: text(value.message, "\u767B\u5F55\u8BF4\u660E", MAX_MESSAGE) },
     ...value.startedAt === void 0 ? {} : { startedAt: isoTime(value.startedAt, "\u767B\u5F55\u5F00\u59CB\u65F6\u95F4") },
     ...value.finishedAt === void 0 ? {} : { finishedAt: isoTime(value.finishedAt, "\u767B\u5F55\u7ED3\u675F\u65F6\u95F4") }
@@ -2825,6 +3307,10 @@ function parseSaveApiKeyRequest(value) {
   if (key.length > MAX_API_KEY) throw new Error(`API Key \u4E0D\u80FD\u8D85\u8FC7 ${MAX_API_KEY} \u5B57\u7B26`);
   return { value: key, expectedRevision: text(value.expectedRevision, "\u914D\u7F6E\u7248\u672C", MAX_REVISION) };
 }
+function parseActivationOpenState(value) {
+  if (!record(value)) throw new Error("\u6388\u6743\u9875\u6253\u5F00\u7ED3\u679C\u5FC5\u987B\u662F\u5BF9\u8C61");
+  return { code: member(value.code, ACTIVATION_OPEN_CODES, "\u6388\u6743\u9875\u6253\u5F00\u7ED3\u679C"), opened: flag(value.opened, "\u6388\u6743\u9875\u662F\u5426\u5DF2\u6253\u5F00") };
+}
 
 // src/index.ts
 var name = "llm-opendesign-corouter";
@@ -2834,17 +3320,20 @@ var SESSION = credentialKey(name, "console");
 var hash = (value) => createHash("sha256").update(JSON.stringify(value) ?? "").digest("hex");
 var needLogin = () => ({ state: "need-login", updatedAt: (/* @__PURE__ */ new Date()).toISOString(), windows: [], balances: {}, note: "\u5C1A\u672A\u8BFB\u53D6\u989D\u5EA6\uFF1B\u53EF\u4F7F\u7528\u684C\u9762\u767B\u5F55\u6001\u6216\u5728\u8FDE\u63A5\u9875\u767B\u5F55" });
 function grantOf(value) {
-  if (value?.kind !== "grant" || !record(value.payload) || typeof value.payload.cookie !== "string") return;
+  if (value?.kind !== "grant" || !record(value.payload)) return;
+  if (value.payload.kind === "device") return deviceGrant(value.payload);
+  if (typeof value.payload.cookie !== "string") return;
   return { cookie: value.payload.cookie, ...typeof value.payload.expiresAt === "number" ? { expiresAt: value.payload.expiresAt } : {} };
 }
-var _saveApiKey_dec, _cancelLogin_dec, _loginStatus_dec, _startLogin_dec, _refreshQuotaNow_dec, _refreshQuota_dec, _refreshModels_dec, _status_dec, _a, _init;
-var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status_dec = [Remote("status")], _refreshModels_dec = [Remote("refreshModels")], _refreshQuota_dec = [Remote("refreshQuota")], _refreshQuotaNow_dec = [Remote("refreshQuotaNow")], _startLogin_dec = [Remote("startLogin")], _loginStatus_dec = [Remote("loginStatus")], _cancelLogin_dec = [Remote("cancelLogin")], _saveApiKey_dec = [Remote("saveApiKey")], _a) {
+var _saveApiKey_dec, _openActivationPage_dec, _cancelLogin_dec, _loginStatus_dec, _startLogin_dec, _refreshQuotaNow_dec, _refreshQuota_dec, _refreshModels_dec, _status_dec, _a, _init;
+var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status_dec = [Remote("status")], _refreshModels_dec = [Remote("refreshModels")], _refreshQuota_dec = [Remote("refreshQuota")], _refreshQuotaNow_dec = [Remote("refreshQuotaNow")], _startLogin_dec = [Remote("startLogin")], _loginStatus_dec = [Remote("loginStatus")], _cancelLogin_dec = [Remote("cancelLogin")], _openActivationPage_dec = [Remote("openActivationPage")], _saveApiKey_dec = [Remote("saveApiKey")], _a) {
   constructor(ctx, config, dependencies = { resolveSession, readQuota, readDesktopQuota }) {
     super(ctx, "openDesignCoRouter");
     this.dependencies = dependencies;
     __runInitializers(_init, 5, this);
     __publicField(this, "_config");
     __publicField(this, "_login");
+    __publicField(this, "_activation");
     __publicField(this, "_lifetime", new AbortController());
     __publicField(this, "_revision", randomUUID2());
     __publicField(this, "_fingerprint", "");
@@ -2871,13 +3360,7 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
         this._credentials();
         return { revision: expectedRevision, sessionHash: hash(state.sessionRecord), configHash: hash(state.config) };
       },
-      verify: async (cookie, signal) => {
-        const session = cookieSession(cookie, "login");
-        if (!session) throw new ConsoleError("auth");
-        const quota = await this.dependencies.readQuota(session, signal);
-        return { balanceOk: true, coverage: quota.state === "ok" ? "complete" : "partial", windows: quota.windows };
-      },
-      commit: async (cookie, captured, signal, expiresAt) => {
+      commit: async (tokens, captured, signal) => {
         if (!record(captured) || typeof captured.revision !== "string" || typeof captured.sessionHash !== "string" || typeof captured.configHash !== "string") throw this._conflict();
         await this._state();
         this._expect(captured.revision);
@@ -2885,14 +3368,27 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
         await this._credentials().modifyRecord(SESSION, async (current) => {
           signal.throwIfAborted();
           if (hash(current) !== captured.sessionHash || hash(this._config()) !== captured.configHash) throw this._conflict();
-          return { kind: "grant", payload: { cookie, expiresAt, savedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+          const grant = deviceGrant({ kind: "device", ...tokens });
+          if (!grant) throw new ConsoleError("auth");
+          return { kind: "grant", payload: { ...grant, savedAt: (/* @__PURE__ */ new Date()).toISOString() } };
         });
         this._invalidateQuota();
+        this._modelsFingerprint = "";
+        this._invalidateModels();
+      }
+    }, {
+      ...dependencies.loginOptions,
+      // The Host owns the temporary window, so it closes it on every terminal transition —
+      // including expiry, which happens on a timer even when no UI is polling.
+      onSettled: () => {
+        void this._activation.close();
       }
     });
+    this._activation = new ActivationLauncher(dependencies.activationOptions);
     ctx.effect(() => () => {
       this._lifetime.abort();
       this._login.dispose();
+      return this._activation.dispose();
     });
   }
   dependencies;
@@ -2904,28 +3400,43 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
     if (!service) throw new RemoteError("opendesign/credentials-unavailable", "DSH \u51ED\u636E\u670D\u52A1\u4E0D\u53EF\u7528\uFF1B\u53EF\u5148\u4F7F\u7528\u542F\u52A8\u73AF\u5883\u53D8\u91CF", void 0);
     return service;
   }
-  async resolveApiKey(ref) {
+  async _key(ref, baseURL, apiRecord, sessionRecord) {
     const credentials = this.ctx.get("credentials");
     const ambient = credentials ? (await credentials.resolve(credentialRef(ref)))?.value : launchEnvironmentOf(this.ctx).get(ref)?.value;
     if (ambient?.trim()) return ambient;
-    const saved = await credentials?.readRecord(API_KEY);
-    return saved?.kind === "api-key" ? saved.key : void 0;
+    if (apiRecord?.kind === "api-key" && apiRecord.key?.trim()) return apiRecord.key;
+    const grant = grantOf(sessionRecord);
+    return isOfficialRuntimeUrl(baseURL) && grant && "kind" in grant && grant.kind === "device" ? grant.runtimeKey : void 0;
+  }
+  async resolveApiKey(ref, baseURL = this._config().baseURL) {
+    const credentials = this.ctx.get("credentials");
+    const [apiRecord, sessionRecord] = await Promise.all([credentials?.readRecord(API_KEY), credentials?.readRecord(SESSION)]);
+    return this._key(ref, baseURL, apiRecord, sessionRecord);
+  }
+  _invalidateModels() {
+    const changed = this._modelsUpdatedAt !== void 0;
+    this._modelsEpoch++;
+    this._modelsController?.abort();
+    this._modelsPending = void 0;
+    this._models = MODELS;
+    this._modelsUpdatedAt = void 0;
+    this._modelsError = void 0;
+    if (changed) {
+      try {
+        this.dependencies.modelsChanged?.();
+      } catch {
+      }
+    }
   }
   async _state() {
     const credentials = this.ctx.get("credentials"), config = this._config();
-    const [apiRecord, sessionRecord, key] = await Promise.all([credentials?.readRecord(API_KEY), credentials?.readRecord(SESSION), this.resolveApiKey(config.apiKeyEnv)]);
+    const [apiRecord, sessionRecord] = await Promise.all([credentials?.readRecord(API_KEY), credentials?.readRecord(SESSION)]);
+    const key = await this._key(config.apiKeyEnv, config.baseURL, apiRecord, sessionRecord);
     const state = { apiRecord, sessionRecord, key, config };
     const modelsFingerprint = hash({ key, baseURL: config.baseURL });
     if (modelsFingerprint !== this._modelsFingerprint) {
-      const changed = this._modelsUpdatedAt !== void 0;
       this._modelsFingerprint = modelsFingerprint;
-      this._modelsEpoch++;
-      this._modelsController?.abort();
-      this._modelsPending = void 0;
-      this._models = MODELS;
-      this._modelsUpdatedAt = void 0;
-      this._modelsError = void 0;
-      if (changed) this.dependencies.modelsChanged?.();
+      this._invalidateModels();
     }
     const fingerprint = hash(state);
     if (fingerprint !== this._fingerprint) {
@@ -3048,9 +3559,10 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
     let identity;
     let refreshFailed = false;
     try {
+      const grant = grantOf(await this.ctx.get("credentials")?.readRecord(SESSION));
       const authDeps = {
         useDesktop: config.useDesktopCredential,
-        readGrant: async () => grantOf(await this.ctx.get("credentials")?.readRecord(SESSION)),
+        readGrant: async () => grant,
         resolveRef: async (ref) => {
           const credentials = this.ctx.get("credentials");
           return credentials ? (await credentials.resolve(credentialRef(ref)))?.value : launchEnvironmentOf(this.ctx).get(ref)?.value;
@@ -3068,7 +3580,10 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
             if (fallback.state === "ready") {
               try {
                 const complete = await this.dependencies.readQuota(fallback.session, signal);
-                if (complete.state === "ok" && (complete.windows.length > 0 || complete.eligible === false)) result = { ...complete, note: `\u684C\u9762\u767B\u5F55\u6001\u4EC5\u63D0\u4F9B\u90E8\u5206\u989D\u5EA6\uFF1B\u5F53\u524D\u663E\u793A\u72EC\u7ACB\u767B\u5F55\u8D26\u53F7\u7684\u5B8C\u6574\u989D\u5EA6\u3002${complete.note ? ` ${complete.note}` : ""}` };
+                if (complete.state === "ok" && (complete.windows.length > 0 || complete.eligible === false)) {
+                  result = { ...complete, note: `\u684C\u9762\u767B\u5F55\u6001\u4EC5\u63D0\u4F9B\u90E8\u5206\u989D\u5EA6\uFF1B\u5F53\u524D\u663E\u793A\u72EC\u7ACB\u767B\u5F55\u8D26\u53F7\u7684\u5B8C\u6574\u989D\u5EA6\u3002${complete.note ? ` ${complete.note}` : ""}` };
+                  identity = hash(fallback.session);
+                }
               } catch (error) {
                 if (signal.aborted) throw error;
               }
@@ -3078,6 +3593,7 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
           if (!(error instanceof ConsoleError) || !["auth", "permission"].includes(error.kind)) throw error;
           const fallback = await this.dependencies.resolveSession({ ...authDeps, useDesktop: false });
           if (fallback.state !== "ready") throw new ConsoleError("auth");
+          identity = hash(fallback.session);
           result = await this.dependencies.readQuota(fallback.session, signal);
         }
       }
@@ -3124,6 +3640,12 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
   cancelLogin(input) {
     return parseLoginState(this._login.cancel(parseCancelLoginRequest(input)));
   }
+  async openActivationPage() {
+    const url = this._login.activationLink();
+    if (url === void 0) return { code: "no-link", opened: false };
+    const result = await this._activation.open(url);
+    return parseActivationOpenState({ code: result.code, opened: result.opened });
+  }
   async saveApiKey(input) {
     const request = parseSaveApiKeyRequest(input), state = await this._state();
     this._expect(request.expectedRevision);
@@ -3143,6 +3665,7 @@ __decorateElement(_init, 1, "refreshQuotaNow", _refreshQuotaNow_dec, OpenDesignC
 __decorateElement(_init, 1, "startLogin", _startLogin_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "loginStatus", _loginStatus_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "cancelLogin", _cancelLogin_dec, OpenDesignCoRouterService);
+__decorateElement(_init, 1, "openActivationPage", _openActivationPage_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "saveApiKey", _saveApiKey_dec, OpenDesignCoRouterService);
 __decoratorMetadata(_init, OpenDesignCoRouterService);
 function apply(ctx, config) {
@@ -3155,7 +3678,7 @@ function apply(ctx, config) {
   const adapter = new CoRouterAdapter({
     config: current,
     models: () => service.modelCatalog(),
-    apiKey: (ref) => service.resolveApiKey(ref),
+    apiKey: (ref, baseURL) => service.resolveApiKey(ref, baseURL),
     onEmptyTurn: () => {
       service.guardedTurns++;
     },
@@ -3178,7 +3701,7 @@ function apply(ctx, config) {
   ctx.llm.registerModelDiscovery(SETTINGS_NS, async (request, signal) => {
     if (request.provider !== void 0 && ![PLAN_PROVIDER, PAID_PROVIDER].includes(request.provider)) throw new LlmError11("\u4E0D\u662F\u672C\u63D2\u4EF6\u7684\u6A21\u578B\u901A\u9053", "INVALID_REQUEST");
     const config2 = current();
-    const key = request.apiKey ?? await service.resolveApiKey(config2.apiKeyEnv);
+    const key = request.apiKey ?? await service.resolveApiKey(config2.apiKeyEnv, config2.baseURL);
     if (!key) throw new LlmError11("\u8BF7\u5148\u914D\u7F6E CoRouter API Key", "MISSING_CREDENTIAL");
     const models = await fetchModelCatalog(config2.baseURL, key, signal);
     return models.map((row) => ({ id: row.id, name: row.name, ...row.contextWindow === void 0 ? {} : { contextWindow: row.contextWindow }, ...row.maxOutputTokens === void 0 ? {} : { maxTokens: row.maxOutputTokens }, ...row.inputModalities ? { inputModalities: row.inputModalities } : {} }));