@qredence/fleet 0.9.0 → 0.10.1

package/dist/web/server/{chunk-TTNONWZZ.js → chunk-LEZMRXSP.js}

@@ -78,7 +78,7 @@ import {
   external_exports,
   isServer,
   iso_exports
-} from "./chunk-KDCSEISZ.js";
+} from "./chunk-NZCEQWK2.js";
 import {
   LazyMotion,
   MotionConfig,
@@ -123,7 +123,7 @@ import {
   lazyRouteComponent
 } from "./chunk-35RIM6VP.js";
 
-// web/app/dist/server/assets/router-CnBux_Ld.js
+// web/app/dist/server/assets/router-DXxChQOI.js
 import { useEffect, useLayoutEffect, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { chmod, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
@@ -134,7 +134,7 @@ import { arch, homedir, platform, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createHash, randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, buildSessionContext, migrateSessionEntries, parseSessionEntries } from "prime-agent";
+import { AuthStorage, DefaultResourceLoader, SettingsManager, buildSessionContext, migrateSessionEntries, parseSessionEntries } from "prime-agent";
 var CSP_META = `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; font-src 'none'; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'; media-src data:; navigate-to 'none';">`;
 var MAX_TITLE_BYTES = 240;
 var FORBIDDEN_ELEMENTS = /<(?:link|iframe|object|embed|base|form|portal|frameset)\b/i;
@@ -2194,7 +2194,7 @@ function getQueryClient() {
   if (!browserQueryClient) browserQueryClient = makeQueryClient();
   return browserQueryClient;
 }
-var globals_default = "/assets/globals-DJhWyayo.css";
+var globals_default = "/assets/globals-DDDleTbS.css";
 var Route$32 = createRootRoute({
   head: () => ({
     meta: [
@@ -2266,11 +2266,11 @@ function RootDocument({ children }) {
     })]
   });
 }
-var $$splitComponentImporter$2 = () => import("./routes-BUGzvQoO-WW43X7W2.js").then((n) => n.t);
+var $$splitComponentImporter$2 = () => import("./routes-D-g2ILNg-LDYCQ4NU.js").then((n) => n.t);
 var Route$31 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter$2, "component") });
-var $$splitComponentImporter$1 = () => import("./agents-BwzqhPjK-ANFHE5AG.js");
+var $$splitComponentImporter$1 = () => import("./agents-DOgCHixY-KUZP2VDO.js");
 var Route$30 = createFileRoute("/agents")({ component: lazyRouteComponent($$splitComponentImporter$1, "component") });
-var $$splitComponentImporter = () => import("./connectors-C0xm91Ss-DJVBGD73.js");
+var $$splitComponentImporter = () => import("./connectors-Dv_uPdv0-2X5VWQXK.js");
 var Route$29 = createFileRoute("/connectors")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
 var ManagedAttachmentValidationError = class extends Error {
   status;
@@ -4135,12 +4135,56 @@ var FleetDaemonAgentConnection = class FleetDaemonAgentConnection2 {
     if (this.closeClientOnDispose) this.client.close();
   }
 };
+var MODEL_CATALOG_MAX_AGE_MS = 5e3;
+function cacheState() {
+  const globalStore2 = globalThis;
+  globalStore2.__fleetModelCatalogCache ??= { generation: 0 };
+  return globalStore2.__fleetModelCatalogCache;
+}
+function readModelCatalogSnapshot(maxAgeMs = MODEL_CATALOG_MAX_AGE_MS) {
+  const { snapshot } = cacheState();
+  if (!snapshot) return void 0;
+  return Date.now() - snapshot.fetchedAt <= maxAgeMs ? snapshot.catalog : void 0;
+}
+async function loadModelCatalog(refresh, maxAgeMs = MODEL_CATALOG_MAX_AGE_MS, attemptsRemaining = 1) {
+  const cached = readModelCatalogSnapshot(maxAgeMs);
+  if (cached) return cached;
+  const state = cacheState();
+  if (!state.inFlight) {
+    const startedAt = state.generation;
+    state.inFlight = (async () => {
+      try {
+        const next = {
+          catalog: await refresh(),
+          fetchedAt: Date.now()
+        };
+        const current = cacheState();
+        if (current.generation !== startedAt) return void 0;
+        current.snapshot = next;
+        current.lastGood = next;
+        return next;
+      } finally {
+        cacheState().inFlight = void 0;
+      }
+    })();
+  }
+  const settled = await state.inFlight;
+  if (settled) return settled.catalog;
+  if (attemptsRemaining <= 0) {
+    const lastGood = cacheState().lastGood;
+    if (lastGood) return lastGood.catalog;
+    throw new Error("The model catalog kept changing while it was being read. Try again.");
+  }
+  return loadModelCatalog(refresh, maxAgeMs, attemptsRemaining - 1);
+}
+function invalidateModelCatalog() {
+  const state = cacheState();
+  state.snapshot = void 0;
+  state.generation += 1;
+}
 function createLegacyAuthStorage(authPath) {
   return AuthStorage.create(authPath);
 }
-function createLegacyModelRegistry(authStorage, modelsJsonPath) {
-  return ModelRegistry.create(authStorage, modelsJsonPath);
-}
 function createLegacySettingsManager(cwd, agentDir) {
   return SettingsManager.create(cwd, agentDir);
 }
@@ -4522,17 +4566,14 @@ function resolveDefaultWorkspaceRoot(startDir, env = process.env) {
 function createPrimeConfig(initialCwd) {
   const agentDir = resolveAgentDir();
   const authStorage = createLegacyAuthStorage(join(agentDir, "auth.json"));
-  const modelRegistry2 = createLegacyModelRegistry(authStorage, join(agentDir, "models.json"));
   const projectRegistry = new ProjectRegistry(agentDir, initialCwd);
   const currentDefaultCwd = resolve(initialCwd);
-  const defaultSettings = createLegacySettingsManager(currentDefaultCwd, agentDir);
   const settingsByCwd = /* @__PURE__ */ new Map();
-  settingsByCwd.set(currentDefaultCwd, defaultSettings);
+  settingsByCwd.set(currentDefaultCwd, createLegacySettingsManager(currentDefaultCwd, agentDir));
   return {
     authStorage,
-    modelRegistry: modelRegistry2,
     get defaultSettings() {
-      return defaultSettings;
+      return this.settingsFor(currentDefaultCwd);
     },
     get defaultCwd() {
       return currentDefaultCwd;
@@ -4540,13 +4581,15 @@ function createPrimeConfig(initialCwd) {
     agentDir,
     projectRegistry,
     settingsFor(cwd) {
-      if (cwd === currentDefaultCwd) return defaultSettings;
       const existing = settingsByCwd.get(cwd);
       if (existing) return existing;
       const created = createLegacySettingsManager(cwd, agentDir);
       settingsByCwd.set(cwd, created);
       return created;
     },
+    invalidateSettings() {
+      settingsByCwd.clear();
+    },
     resourceLoaderFor(cwd) {
       return loadLegacyResources({
         cwd,
@@ -4556,14 +4599,14 @@ function createPrimeConfig(initialCwd) {
     },
     reloadAuth() {
       this.authStorage.reload();
-      this.modelRegistry.refresh();
+      invalidateModelCatalog();
     }
   };
 }
 function getPrimeConfig() {
   const globalStore2 = globalThis;
   const existing = globalStore2.__primeConfig;
-  if (!existing || !existing.projectRegistry) globalStore2.__primeConfig = createPrimeConfig(resolveDefaultWorkspaceRoot(process.cwd()));
+  if (!existing || !existing.projectRegistry || !existing.invalidateSettings) globalStore2.__primeConfig = createPrimeConfig(resolveDefaultWorkspaceRoot(process.cwd()));
   return globalStore2.__primeConfig;
 }
 var PRIME_AGENT_RUNTIME_default = {
@@ -4598,7 +4641,7 @@ var PRIME_AGENT_RUNTIME_default = {
     }
   }
 };
-function runtimeArchiveTarget(os, cpu) {
+function runtimeTarget(os = platform(), cpu = arch()) {
   const target = `${os}-${cpu}`;
   if (![
     "darwin-arm64",
@@ -4608,44 +4651,53 @@ function runtimeArchiveTarget(os, cpu) {
   ].includes(target)) throw new Error(`Fleet's Rust Prime Agent runtime does not support ${target}; supported targets: darwin-arm64, darwin-x64, linux-arm64, linux-x64.`);
   return target;
 }
-async function ensurePrimeAgentRuntime(options = {}) {
-  const selectedTarget = options.target ?? runtimeArchiveTarget(platform(), arch());
-  const runtime = PRIME_AGENT_RUNTIME_default.rust;
-  const asset = runtime.platforms[selectedTarget];
-  if (!asset) throw new Error(`No pinned Prime Agent runtime archive for ${selectedTarget}`);
-  const installRoot = options.installRoot ?? join(options.home ?? homedir(), ".prime", "fleet", "runtimes", runtime.version, selectedTarget);
-  const binary = join(installRoot, "prime-agent");
-  if (await executableMatches(binary, asset.executableSha256)) return binary;
-  await mkdir(dirname(installRoot), {
+async function ensurePrimeRuntime({ manifest, installRoot, home = homedir(), fetch: fetchImpl = fetch, target = runtimeTarget() }) {
+  const runtime = manifest.rust;
+  const asset = runtime?.platforms?.[target];
+  if (!asset) throw new Error(`Fleet has no pinned Prime Agent runtime for ${target}`);
+  const destination = installRoot ?? join(home, ".prime", "fleet", "runtimes", runtime.version, target);
+  const executable = join(destination, "prime-agent");
+  const packagedRuntime = join(destination, "prime-agent-runtime");
+  if (await matchesDigest(executable, asset.executableSha256) && await directoryExists(packagedRuntime)) return executable;
+  await mkdir(dirname(destination), {
     recursive: true,
     mode: 448
   });
-  const staging = await mkdtemp(join(dirname(installRoot), ".fleet-prime-runtime-"));
+  const staging = await mkdtemp(join(dirname(destination), ".fleet-prime-runtime-"));
   try {
     const archivePath = join(staging, asset.archive);
-    const response = await (options.fetch ?? fetch)(`${runtime.baseUrl}/${asset.archive}`, { signal: AbortSignal.timeout(12e4) });
+    const response = await fetchImpl(`${runtime.baseUrl}/${asset.archive}`, { signal: AbortSignal.timeout(12e4) });
     if (!response.ok) throw new Error(`Could not download Prime Agent ${runtime.version} (${response.status}). Check your network and retry.`);
-    const bytes = Buffer.from(await response.arrayBuffer());
-    if (digest(bytes) !== asset.sha256) throw new Error(`Prime Agent ${runtime.version} archive checksum mismatch; refusing to install it.`);
-    await writeFile(archivePath, bytes, { mode: 384 });
-    const extractRoot = join(staging, "extracted");
-    await mkdir(extractRoot);
-    const extraction = spawnSync("tar", [
+    const archive = Buffer.from(await response.arrayBuffer());
+    if (digest(archive) !== asset.sha256) throw new Error(`Prime Agent ${runtime.version} archive checksum mismatch; refusing to install it.`);
+    await writeFile(archivePath, archive, { mode: 384 });
+    const unpacked = join(staging, "unpacked");
+    await mkdir(unpacked);
+    const result = spawnSync("tar", [
       "-xzf",
       archivePath,
       "-C",
-      extractRoot
+      unpacked
     ], { encoding: "utf8" });
-    if (extraction.status !== 0) throw new Error(`Could not extract Prime Agent runtime: ${extraction.stderr || "tar failed"}`);
-    const extractedBinary = join(extractRoot, "prime-agent");
-    if (!await executableMatches(extractedBinary, asset.executableSha256)) throw new Error("Extracted Prime Agent executable checksum mismatch; refusing to install it.");
+    if (result.status !== 0) throw new Error(`Could not extract Prime Agent runtime: ${result.stderr || "tar failed"}`);
+    const extractedBinary = join(unpacked, "prime-agent");
+    if (!await matchesDigest(extractedBinary, asset.executableSha256)) throw new Error("Extracted Prime Agent executable checksum mismatch; refusing to install it.");
     await chmod(extractedBinary, 493);
-    await mkdir(installRoot, {
+    await mkdir(destination, {
       recursive: true,
       mode: 448
     });
-    await rename(extractedBinary, binary);
-    return binary;
+    const extractedRuntime = join(unpacked, "prime-agent-runtime");
+    if (await directoryExists(extractedRuntime)) {
+      await rename(packagedRuntime, join(staging, "previous-runtime")).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+      await rename(extractedRuntime, packagedRuntime).catch((error) => {
+        if (error.code !== "ENOTEMPTY" && error.code !== "EEXIST") throw error;
+      });
+    }
+    await rename(extractedBinary, executable);
+    return executable;
   } finally {
     await rm(staging, {
       recursive: true,
@@ -4653,7 +4705,15 @@ async function ensurePrimeAgentRuntime(options = {}) {
     });
   }
 }
-async function executableMatches(path, expected) {
+async function directoryExists(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return false;
+    throw error;
+  }
+}
+async function matchesDigest(path, expected) {
   let file2;
   try {
     file2 = await open(path, "r");
@@ -4664,8 +4724,14 @@ async function executableMatches(path, expected) {
     await file2?.close();
   }
 }
-function digest(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function ensurePrimeAgentRuntime(options = {}) {
+  return ensurePrimeRuntime({
+    manifest: PRIME_AGENT_RUNTIME_default,
+    ...options
+  });
 }
 var DAEMON_STARTUP_TIMEOUT_MS = 3e4;
 var DAEMON_PROBE_TIMEOUT_MS = 1e3;
@@ -4750,6 +4816,10 @@ async function probeDaemon(socketPath) {
     client.close();
   }
 }
+function describeDaemonSpawnError(error, command, options) {
+  if (error.code !== "ENOENT") return `Could not start Prime Agent ${options.noun}: ${error.code ?? error.message}`;
+  return `Could not start Prime Agent ${options.noun}: ${command} was not found, or its working directory ${options.cwd} does not exist.`;
+}
 async function startDaemon(socketPath, spawnCwd) {
   const initialProbe = await probeDaemon(socketPath);
   if (initialProbe.status === "compatible") return;
@@ -4773,10 +4843,16 @@ async function startDaemon(socketPath, spawnCwd) {
   const deadline = Date.now() + DAEMON_STARTUP_TIMEOUT_MS;
   while (Date.now() < deadline) {
     let spawnError = spawnErrors[0];
-    if (spawnError) throw new Error(spawnError.code === "ENOENT" ? `Prime Agent binary not found: ${command}` : `Could not start Prime Agent binary ${command}: ${spawnError.code ?? spawnError.message}`);
+    if (spawnError) throw new Error(describeDaemonSpawnError(spawnError, command, {
+      noun: "binary",
+      cwd: spawnCwd
+    }));
     const probe = await probeDaemon(socketPath);
     spawnError = spawnErrors[0];
-    if (spawnError) throw new Error(spawnError.code === "ENOENT" ? `Prime Agent binary not found: ${command}` : `Could not start Prime Agent daemon: ${spawnError.code || spawnError.message}`);
+    if (spawnError) throw new Error(describeDaemonSpawnError(spawnError, command, {
+      noun: "daemon",
+      cwd: spawnCwd
+    }));
     if (probe.status === "compatible") return;
     if (probe.status === "incompatible") throw new Error(`The Prime Agent daemon socket at ${socketPath} was claimed by a non-pinned daemon (${probe.detail}). Stop that daemon or configure a different daemon socket path.`);
     await delay(DAEMON_POLL_DELAY_MS);
@@ -4916,15 +4992,15 @@ async function withTransientDaemonSession(cwd, work) {
 }
 var modelCatalogListeners = /* @__PURE__ */ new Set();
 function notifyDaemonModelCatalogChanged() {
-  try {
-    getPrimeConfig().modelRegistry.refresh();
-  } catch {
-  }
+  invalidateModelCatalog();
   for (const listener of [...modelCatalogListeners]) try {
     listener();
   } catch {
   }
 }
+function readDaemonModelCatalog(sessionCwd) {
+  return loadModelCatalog(() => withTransientDaemonSession(sessionCwd, (client, activeSessionId) => client.getModelCatalog(activeSessionId)));
+}
 function applySessionBinding(route, frame) {
   if (!isDaemonSessionBindingFrame(frame)) return void 0;
   if (frame.previousActiveSessionId !== route.activeSessionId && frame.activeSessionId !== route.activeSessionId) return;
@@ -6974,154 +7050,687 @@ async function copyManagedPlanPresentationsForFork(source, forked, forkedMessage
   if (copied.length === 0) return;
   await writePresentationsAtomic(forked, copied);
 }
-var DEFAULT_TIMEOUT_MS = 6e4;
-var PendingDialogRegistry = class {
-  bySession = /* @__PURE__ */ new Map();
-  defaultTimeoutMs;
-  emitFrame;
-  constructor(options) {
-    this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.emitFrame = options.emitFrame;
-  }
-  get(sessionId, toolCallId) {
-    return this.bySession.get(sessionId)?.get(toolCallId);
-  }
-  list(sessionId) {
-    const map = this.bySession.get(sessionId);
-    return map ? [...map.values()] : [];
-  }
-  snapshot(sessionId) {
-    return this.list(sessionId).map((d) => ({
-      sessionId: d.sessionId,
-      toolCallId: d.toolCallId,
-      kind: d.kind,
-      title: d.title,
-      ...d.message ? { message: d.message } : {},
-      ...d.options ? { options: [...d.options] } : {},
-      ...d.questions ? { questions: [...d.questions] } : {},
-      ...d.placeholder ? { placeholder: d.placeholder } : {},
-      createdAt: d.createdAt,
-      ...d.timeoutMs !== void 0 ? { timeoutMs: d.timeoutMs } : {}
-    }));
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_RETRY_MS = 25;
+function isJsonObject$2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorCode(error) {
+  return isJsonObject$2(error) && typeof error.code === "string" ? error.code : void 0;
+}
+async function readJsonObjectFile(path, parse = JSON.parse) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return { kind: "missing" };
+    return {
+      kind: "invalid",
+      error: error instanceof Error ? error.message : "unreadable"
+    };
   }
-  async open(args) {
-    const map = this.forSession(args.sessionId);
-    const timeoutDuration = args.timeoutMs ?? this.defaultTimeoutMs;
-    return await new Promise((resolve2, reject) => {
-      let settled = false;
-      const dialog = {
-        sessionId: args.sessionId,
-        toolCallId: args.toolCallId,
-        kind: args.kind,
-        title: args.title,
-        message: args.message,
-        options: args.options,
-        questions: args.questions,
-        placeholder: args.placeholder,
-        createdAt: Date.now(),
-        timeoutMs: timeoutDuration,
-        resolve: (value) => {
-          if (settled) return;
-          settled = true;
-          resolve2(value);
-        },
-        reject: (err) => {
-          if (settled) return;
-          settled = true;
-          reject(err);
-        },
-        timer: setTimeout(() => {
-          if (settled) return;
-          this.cancel(args.sessionId, args.toolCallId, "timeout");
-        }, timeoutDuration)
-      };
-      map.set(args.toolCallId, dialog);
-      this.emitFrame(args.sessionId, {
-        type: "tool",
-        part: args.signalFrame
-      });
-    });
+  try {
+    const parsed = parse(raw);
+    if (!isJsonObject$2(parsed)) return {
+      kind: "invalid",
+      error: "expected a JSON object"
+    };
+    return {
+      kind: "ok",
+      value: parsed
+    };
+  } catch (error) {
+    return {
+      kind: "invalid",
+      error: error instanceof Error ? error.message : "invalid JSON"
+    };
   }
-  /**
-  * Resolve a pending dialog on `POST /api/chat/question`. Returns true iff a
-  * pending entry was found (caller returns 404 when false so the client can
-  * distinguish "already answered" from "unknown toolCallId").
-  */
-  answer(sessionId, toolCallId, answer) {
-    const dialog = this.get(sessionId, toolCallId);
-    if (!dialog) return false;
-    clearTimeout(dialog.timer);
-    this.bySession.get(sessionId)?.delete(toolCallId);
-    dialog.resolve(answer);
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
     return true;
+  } catch (error) {
+    return errorCode(error) === "EPERM";
   }
-  /**
-  * Cancel a pending dialog, emitting a `tool-Question` cancellation frame so
-  * connected/replaying UIs can clear the question card.
-  */
-  cancel(sessionId, toolCallId, reason) {
-    const dialog = this.get(sessionId, toolCallId);
-    if (!dialog) return false;
-    clearTimeout(dialog.timer);
-    this.bySession.get(sessionId)?.delete(toolCallId);
-    const frame = {
-      type: "tool",
-      part: {
-        type: "tool-Question",
-        toolCallId,
-        state: "output-error",
-        output: {
-          cancelled: true,
-          reason,
-          title: dialog.title
-        }
+}
+async function acquireLock(lockPath) {
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  await mkdir(dirname(lockPath), { recursive: true });
+  for (; ; ) try {
+    const descriptor = openSync(lockPath, "wx", 384);
+    writeFileSync(descriptor, String(process.pid), "utf8");
+    closeSync(descriptor);
+    return { release: () => {
+      rmSync(lockPath, { force: true });
+    } };
+  } catch (error) {
+    if (errorCode(error) !== "EEXIST") throw error;
+    let raw;
+    try {
+      const reader = openSync(lockPath, "r");
+      try {
+        raw = readFileSync(reader, "utf8");
+      } finally {
+        closeSync(reader);
       }
-    };
-    this.emitFrame(sessionId, frame);
-    dialog.reject(/* @__PURE__ */ new Error(`Question cancelled: ${reason}`));
-    return true;
-  }
-  /** Cancel every pending dialog in a session (used by `abort` and shutdown). */
-  cancelAll(sessionId, reason) {
-    const pending = this.list(sessionId);
-    for (const dialog of pending) {
-      if (this.bySession.get(sessionId)?.get(dialog.toolCallId) === void 0) continue;
-      this.cancel(sessionId, dialog.toolCallId, reason);
+    } catch (readError) {
+      if (errorCode(readError) === "ENOENT") continue;
+      throw readError;
     }
-    return pending.length;
-  }
-  forSession(sessionId) {
-    let existing = this.bySession.get(sessionId);
-    if (!existing) {
-      existing = /* @__PURE__ */ new Map();
-      this.bySession.set(sessionId, existing);
+    const holder = Number.parseInt(raw, 10);
+    if (!isProcessAlive(holder)) {
+      rmSync(lockPath, { force: true });
+      continue;
     }
-    return existing;
-  }
-};
-var RingBuffer = class {
-  entries = [];
-  capacity;
-  nextSeq = 1;
-  generation = crypto.randomUUID();
-  constructor(capacity = 500) {
-    this.capacity = Math.max(1, capacity);
+    if (Date.now() >= deadline) throw new Error(`Timed out waiting for another Fleet write (held by process ${Number.isNaN(holder) ? "unknown" : holder}).`);
+    await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MS));
   }
-  get streamGeneration() {
-    return this.generation;
+}
+function currentMode(path) {
+  try {
+    return statSync(path).mode & 511;
+  } catch {
+    return;
   }
-  push(event, decorate) {
-    const seq = this.nextSeq++;
-    const entry = {
-      seq,
-      event: decorate ? decorate(seq, this.generation) : event
-    };
-    this.entries.push(entry);
-    if (this.entries.length > this.capacity) this.entries.splice(0, this.entries.length - this.capacity);
-    return entry;
+}
+async function writeJsonObjectFile(path, value, options = {}) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const mode = currentMode(path) ?? options.mode ?? 420;
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, "	")}
+`, {
+      encoding: "utf8",
+      mode
+    });
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
   }
-  /**
-  * Replay entries with seq > `lastEventId`. If `lastEventId` is behind the
+}
+var UnwritablePathError = class extends Error {
+  path;
+  cause;
+  constructor(path, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`${path}: ${detail}`);
+    this.path = path;
+    this.cause = cause;
+    this.name = "UnwritablePathError";
+  }
+};
+async function updateJsonObjectFile(path, mutate, options = {}) {
+  const lock = await acquireLock(`${path}.lock`).catch((error) => {
+    throw new UnwritablePathError(path, error);
+  });
+  try {
+    const current = await readJsonObjectFile(path, options.parse);
+    if (current.kind === "invalid") return {
+      status: "refused",
+      reason: `${path} is not a readable JSON object: ${current.error}`
+    };
+    const outcome = mutate(current.kind === "ok" ? current.value : {});
+    if ("refuse" in outcome) return {
+      status: "refused",
+      reason: outcome.refuse
+    };
+    if ("unchanged" in outcome) return {
+      status: "unchanged",
+      value: outcome.unchanged
+    };
+    try {
+      await writeJsonObjectFile(path, outcome.next, { mode: options.mode });
+    } catch (error) {
+      throw new UnwritablePathError(path, error);
+    }
+    return {
+      status: "written",
+      value: outcome.result
+    };
+  } finally {
+    lock.release();
+  }
+}
+var AUTH_FILE = "auth.json";
+function isJsonObject$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function authFilePath(agentDir) {
+  return join(agentDir, AUTH_FILE);
+}
+function isWritableProviderId(providerId) {
+  return providerId.length > 0 && providerId.length <= 128 && !/[\u0000-\u001f/\\]/.test(providerId);
+}
+async function readProviderApiKey(agentDir, providerId) {
+  const current = await readJsonObjectFile(authFilePath(agentDir));
+  if (current.kind !== "ok") return void 0;
+  const entry = current.value[providerId];
+  if (!isJsonObject$1(entry) || entry.type !== "api_key") return void 0;
+  const key = entry.key;
+  return typeof key === "string" ? key : void 0;
+}
+async function setProviderApiKey(agentDir, providerId, key) {
+  if (!isWritableProviderId(providerId)) return {
+    status: "refused",
+    reason: `"${providerId}" is not a valid provider id.`
+  };
+  const trimmed = key.trim();
+  if (trimmed.length === 0) return {
+    status: "refused",
+    reason: "The API key is empty."
+  };
+  const outcome = await updateJsonObjectFile(authFilePath(agentDir), (current) => {
+    const existing = current[providerId];
+    const next = {
+      ...isJsonObject$1(existing) ? existing : {},
+      type: "api_key",
+      key: trimmed
+    };
+    return {
+      next: {
+        ...current,
+        [providerId]: next
+      },
+      result: true
+    };
+  }, { mode: 384 });
+  return outcome.status === "refused" ? outcome : { status: "written" };
+}
+async function configuredProviderIds(agentDir) {
+  const current = await readJsonObjectFile(authFilePath(agentDir));
+  if (current.kind !== "ok") return /* @__PURE__ */ new Set();
+  return new Set(Object.entries(current.value).filter(([, value]) => isJsonObject$1(value)).map(([providerId]) => providerId));
+}
+async function removeProviderCredential(agentDir, providerId) {
+  const outcome = await updateJsonObjectFile(authFilePath(agentDir), (current) => {
+    if (!(providerId in current)) return {
+      next: current,
+      result: "absent"
+    };
+    const next = {};
+    for (const [currentId, value] of Object.entries(current)) if (currentId !== providerId) next[currentId] = value;
+    return {
+      next,
+      result: "removed"
+    };
+  }, { mode: 384 });
+  return outcome.status === "refused" ? outcome : { status: "written" };
+}
+var BUILT_IN_PROVIDER_DISPLAY_NAMES = {
+  anthropic: "Anthropic",
+  "amazon-bedrock": "Amazon Bedrock",
+  "azure-openai-responses": "Azure OpenAI Responses",
+  cerebras: "Cerebras",
+  "cloudflare-ai-gateway": "Cloudflare AI Gateway",
+  "cloudflare-workers-ai": "Cloudflare Workers AI",
+  deepseek: "DeepSeek",
+  fireworks: "Fireworks",
+  google: "Google Gemini",
+  "google-vertex": "Google Vertex AI",
+  groq: "Groq",
+  huggingface: "Hugging Face",
+  "kimi-coding": "Kimi For Coding",
+  mistral: "Mistral",
+  minimax: "MiniMax",
+  "minimax-cn": "MiniMax (China)",
+  moonshotai: "Moonshot AI",
+  "moonshotai-cn": "Moonshot AI (China)",
+  opencode: "OpenCode Zen",
+  "opencode-go": "OpenCode Go",
+  openai: "OpenAI",
+  "openai-codex": "OpenAI Codex",
+  openrouter: "OpenRouter",
+  "prime-agent-traces": "Prime Agent Traces",
+  "prime-inference": "Prime Inference",
+  "vercel-ai-gateway": "Vercel AI Gateway",
+  xai: "xAI",
+  zai: "ZAI",
+  xiaomi: "Xiaomi MiMo",
+  "xiaomi-token-plan-cn": "Xiaomi MiMo Token Plan (China)",
+  "xiaomi-token-plan-ams": "Xiaomi MiMo Token Plan (Amsterdam)",
+  "xiaomi-token-plan-sgp": "Xiaomi MiMo Token Plan (Singapore)",
+  "github-copilot": "GitHub Copilot"
+};
+function isLlmsProviderId(providerId) {
+  return providerId !== "prime-agent-traces";
+}
+function builtInProviderIds() {
+  return Object.keys(BUILT_IN_PROVIDER_DISPLAY_NAMES).filter(isLlmsProviderId);
+}
+var BUILT_IN_PROVIDER_ID_SET = new Set(builtInProviderIds());
+function isBuiltInProviderId(providerId) {
+  return BUILT_IN_PROVIDER_ID_SET.has(providerId);
+}
+function storedApiForCustomProvider(api) {
+  return api === "google-genai" ? "google-generative-ai" : api;
+}
+function uiApiForCustomProvider(value) {
+  if (value === "google-generative-ai") return "google-genai";
+  return isPiCustomProviderApi(value) ? value : void 0;
+}
+function envVarNameForManagedProvider(providerId) {
+  if (providerId === "openai-chat-completions") return "OPENAI_CHAT_COMPLETIONS_API_KEY";
+  const slug = providerId.slice(providerId.indexOf("+") + 1).toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+  return isOccProviderId(providerId) ? `OPENAI_CHAT_COMPLETIONS_${slug}_API_KEY` : `CUSTOM_${slug}_API_KEY`;
+}
+function readModelsJson(filePath) {
+  try {
+    if (!existsSync(filePath)) return {};
+    return parseModelsJson(readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function stripJsonComments(input) {
+  return input.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (match) => match[0] === '"' ? match : "").replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (match, tail) => tail ?? (match[0] === '"' ? match : ""));
+}
+function parseModelsJson(raw) {
+  const parsed = JSON.parse(stripJsonComments(raw));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("models.json must contain an object");
+  return parsed;
+}
+var OPENAI_COMPLETIONS_TOOL_REASONING_NONE_PATTERN = /^(?:[^/]+\/)?gpt-(?:5[.-]6|6)(?:[.-]|$)/i;
+var OPENAI_COMPLETIONS_REASONING_OFF_MAP = {
+  off: "none",
+  minimal: null,
+  low: null,
+  medium: null,
+  high: null,
+  xhigh: null,
+  max: null
+};
+function applyModelDefaults(model, storedApi) {
+  if (storedApi === "openai-completions" && OPENAI_COMPLETIONS_TOOL_REASONING_NONE_PATTERN.test(model.id) && model.reasoning === void 0 && model.thinkingLevelMap === void 0) return {
+    ...model,
+    reasoning: true,
+    thinkingLevelMap: OPENAI_COMPLETIONS_REASONING_OFF_MAP
+  };
+  return model;
+}
+function mergeModelDefinitions(existing, incoming, storedApi) {
+  const existingById = new Map((existing ?? []).map((model) => [model.id, model]));
+  const seen = /* @__PURE__ */ new Set();
+  return incoming.flatMap((model) => {
+    if (seen.has(model.id)) return [];
+    seen.add(model.id);
+    return [applyModelDefaults({
+      ...existingById.get(model.id),
+      ...model
+    }, storedApi)];
+  });
+}
+function listCustomProviders(filePath) {
+  return readModelsJson(filePath).providers ?? {};
+}
+function providersMissingApiKey(filePath) {
+  return Object.entries(listCustomProviders(filePath)).filter(([providerId, entry]) => {
+    if (isBuiltInProviderId(providerId)) return false;
+    return typeof entry.apiKey !== "string" || entry.apiKey.length === 0;
+  }).map(([providerId]) => providerId);
+}
+async function updateModelsJson(filePath, mutate) {
+  const outcome = await updateJsonObjectFile(filePath, (current) => {
+    const next = mutate(current);
+    return next ? {
+      next,
+      result: void 0
+    } : { unchanged: void 0 };
+  }, {
+    mode: 420,
+    parse: parseModelsJson
+  });
+  if (outcome.status === "refused") throw new Error(`Refusing to update models.json because it could not be parsed: ${outcome.reason}`);
+}
+function defaultCompatForCustomProvider(storedApi, baseUrl, existingCompat) {
+  const existingRecord = existingCompat && typeof existingCompat === "object" && !Array.isArray(existingCompat) ? existingCompat : void 0;
+  if (storedApi !== "openai-completions") return existingRecord;
+  try {
+    if (new URL(baseUrl).hostname === "api.openai.com") return existingRecord;
+  } catch {
+  }
+  return {
+    supportsStore: false,
+    ...existingRecord
+  };
+}
+async function upsertCustomProvider(filePath, providerId, input) {
+  await updateModelsJson(filePath, (data) => {
+    const providers = { ...data.providers ?? {} };
+    const existing = providers[providerId] ?? {};
+    const storedApi = storedApiForCustomProvider(input.api);
+    const compat = defaultCompatForCustomProvider(storedApi, input.baseUrl, existing.compat);
+    providers[providerId] = {
+      ...existing,
+      name: input.name ?? existing.name,
+      baseUrl: input.baseUrl,
+      api: storedApi,
+      apiKey: input.apiKey,
+      ...compat ? { compat } : {},
+      models: mergeModelDefinitions(existing.models, input.models, storedApi)
+    };
+    return {
+      ...data,
+      providers
+    };
+  });
+}
+async function addCustomProviderModelIds(filePath, providerId, modelIds) {
+  await updateModelsJson(filePath, (data) => {
+    const providers = { ...data.providers ?? {} };
+    const existing = providers[providerId];
+    if (!existing) return;
+    const compat = typeof existing.api === "string" && typeof existing.baseUrl === "string" ? defaultCompatForCustomProvider(existing.api, existing.baseUrl, existing.compat) : void 0;
+    providers[providerId] = {
+      ...existing,
+      ...compat ? { compat } : {},
+      models: mergeModelDefinitions(existing.models, [...existing.models ?? [], ...modelIds.map((id) => ({ id }))], existing.api)
+    };
+    return {
+      ...data,
+      providers
+    };
+  });
+}
+async function removeCustomProvider(filePath, providerId) {
+  await updateModelsJson(filePath, (data) => {
+    const providers = data.providers;
+    if (!providers || !(providerId in providers)) return;
+    const next = { ...providers };
+    delete next[providerId];
+    return {
+      ...data,
+      providers: next
+    };
+  });
+}
+function isDiscoverableEntry(entry) {
+  const baseUrl = entry?.baseUrl;
+  if (!baseUrl) return false;
+  const api = uiApiForCustomProvider(entry?.api);
+  if (api && !isOccFamilyApi(api)) return false;
+  if (entry?.api && !api) return false;
+  try {
+    const parsed = new URL(baseUrl);
+    return parsed.protocol === "https:" || parsed.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+var PRIME_PROVIDER_ENV_MAP = {
+  openai: "OPENAI_API_KEY",
+  "azure-openai-responses": "AZURE_OPENAI_API_KEY",
+  "prime-inference": "PRIME_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  google: "GEMINI_API_KEY",
+  "google-vertex": "GOOGLE_CLOUD_API_KEY",
+  groq: "GROQ_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  xai: "XAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+  zai: "ZAI_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  minimax: "MINIMAX_API_KEY",
+  "minimax-cn": "MINIMAX_CN_API_KEY",
+  moonshotai: "MOONSHOT_API_KEY",
+  "moonshotai-cn": "MOONSHOT_API_KEY",
+  huggingface: "HF_TOKEN",
+  fireworks: "FIREWORKS_API_KEY",
+  opencode: "OPENCODE_API_KEY",
+  "opencode-go": "OPENCODE_API_KEY",
+  "kimi-coding": "KIMI_API_KEY",
+  "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
+  "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
+  xiaomi: "XIAOMI_API_KEY",
+  "xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+  "xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+  "xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+};
+var MULTI_ENV_PROVIDER_MAP = {
+  anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
+  "github-copilot": [
+    "COPILOT_GITHUB_TOKEN",
+    "GH_TOKEN",
+    "GITHUB_TOKEN"
+  ]
+};
+function providerEnvVarCandidates(providerId) {
+  const multi = MULTI_ENV_PROVIDER_MAP[providerId];
+  if (multi) return multi;
+  const single = PRIME_PROVIDER_ENV_MAP[providerId];
+  return single ? [single] : [];
+}
+var THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var EXPLICIT_ONLY_LEVELS = /* @__PURE__ */ new Set(["xhigh", "max"]);
+function supportedThinkingLevels(model) {
+  if (!model.reasoning) return ["off"];
+  const map = model.thinkingLevelMap;
+  return THINKING_LEVELS.filter((level) => {
+    const mapped = map?.[level];
+    if (mapped === null) return false;
+    if (EXPLICIT_ONLY_LEVELS.has(level)) return mapped !== void 0;
+    return true;
+  });
+}
+var ENV_VAR_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+function declaredApiKeyResolves(declared, env) {
+  if (typeof declared !== "string" || declared.length === 0) return false;
+  if (declared.startsWith("!")) return true;
+  if (!ENV_VAR_NAME_PATTERN.test(declared)) return true;
+  return (env[declared] ?? "").length > 0;
+}
+function hasAmbientCredential(provider, env) {
+  if (provider === "google-vertex") {
+    const hasProject = Boolean(env.GOOGLE_CLOUD_PROJECT || env.GCLOUD_PROJECT);
+    const hasLocation = Boolean(env.GOOGLE_CLOUD_LOCATION);
+    if (!hasProject || !hasLocation) return false;
+    const gacPath = env.GOOGLE_APPLICATION_CREDENTIALS;
+    return existsSync(gacPath || join(homedir(), ".config", "gcloud", "application_default_credentials.json"));
+  }
+  if (provider === "amazon-bedrock") return Boolean(env.AWS_PROFILE || env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY || env.AWS_BEARER_TOKEN_BEDROCK || env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || env.AWS_CONTAINER_CREDENTIALS_FULL_URI || env.AWS_WEB_IDENTITY_TOKEN_FILE);
+  return false;
+}
+function hasEnvironmentCredential(provider, env = process.env) {
+  for (const envVar of providerEnvVarCandidates(provider)) if ((env[envVar] ?? "").length > 0) return true;
+  return hasAmbientCredential(provider, env);
+}
+async function providerAvailability(agentDir, env = process.env) {
+  const storedProviders = await configuredProviderIds(agentDir).catch(() => /* @__PURE__ */ new Set());
+  const declaredKeys = listCustomProviders(`${agentDir}/models.json`);
+  const usableDeclared = /* @__PURE__ */ new Set();
+  for (const [providerId, entry] of Object.entries(declaredKeys)) if (declaredApiKeyResolves(entry.apiKey, env)) usableDeclared.add(providerId);
+  return (provider) => {
+    if (storedProviders.has(provider)) return true;
+    if (hasEnvironmentCredential(provider, env)) return true;
+    return usableDeclared.has(provider);
+  };
+}
+function toChatModelInfo(model, available) {
+  const thinkingLevels = supportedThinkingLevels(model);
+  const fallback = model.reasoning ? "medium" : "off";
+  return {
+    key: `${model.provider}/${model.id}`,
+    provider: model.provider,
+    id: model.id,
+    name: model.name,
+    reasoning: model.reasoning,
+    input: model.input,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    available,
+    thinkingLevels,
+    defaultThinkingLevel: thinkingLevels.includes(fallback) ? fallback : thinkingLevels[0] ?? "off"
+  };
+}
+function toChatModelInfoList(catalog, isProviderAvailable) {
+  return catalog.models.map((model) => toChatModelInfo(model, isProviderAvailable(model.provider)));
+}
+function catalogHasModel(catalog, provider, id) {
+  return catalog.models.some((model) => model.provider === provider && model.id === id);
+}
+function firstAvailableModelId(catalog, isProviderAvailable, provider) {
+  return catalog.models.find((model) => model.provider === provider && isProviderAvailable(model.provider))?.id;
+}
+var DEFAULT_TIMEOUT_MS = 6e4;
+var PendingDialogRegistry = class {
+  bySession = /* @__PURE__ */ new Map();
+  defaultTimeoutMs;
+  emitFrame;
+  constructor(options) {
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.emitFrame = options.emitFrame;
+  }
+  get(sessionId, toolCallId) {
+    return this.bySession.get(sessionId)?.get(toolCallId);
+  }
+  list(sessionId) {
+    const map = this.bySession.get(sessionId);
+    return map ? [...map.values()] : [];
+  }
+  snapshot(sessionId) {
+    return this.list(sessionId).map((d) => ({
+      sessionId: d.sessionId,
+      toolCallId: d.toolCallId,
+      kind: d.kind,
+      title: d.title,
+      ...d.message ? { message: d.message } : {},
+      ...d.options ? { options: [...d.options] } : {},
+      ...d.questions ? { questions: [...d.questions] } : {},
+      ...d.placeholder ? { placeholder: d.placeholder } : {},
+      createdAt: d.createdAt,
+      ...d.timeoutMs !== void 0 ? { timeoutMs: d.timeoutMs } : {}
+    }));
+  }
+  async open(args) {
+    const map = this.forSession(args.sessionId);
+    const timeoutDuration = args.timeoutMs ?? this.defaultTimeoutMs;
+    return await new Promise((resolve2, reject) => {
+      let settled = false;
+      const dialog = {
+        sessionId: args.sessionId,
+        toolCallId: args.toolCallId,
+        kind: args.kind,
+        title: args.title,
+        message: args.message,
+        options: args.options,
+        questions: args.questions,
+        placeholder: args.placeholder,
+        createdAt: Date.now(),
+        timeoutMs: timeoutDuration,
+        resolve: (value) => {
+          if (settled) return;
+          settled = true;
+          resolve2(value);
+        },
+        reject: (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        },
+        timer: setTimeout(() => {
+          if (settled) return;
+          this.cancel(args.sessionId, args.toolCallId, "timeout");
+        }, timeoutDuration)
+      };
+      map.set(args.toolCallId, dialog);
+      this.emitFrame(args.sessionId, {
+        type: "tool",
+        part: args.signalFrame
+      });
+    });
+  }
+  /**
+  * Resolve a pending dialog on `POST /api/chat/question`. Returns true iff a
+  * pending entry was found (caller returns 404 when false so the client can
+  * distinguish "already answered" from "unknown toolCallId").
+  */
+  answer(sessionId, toolCallId, answer) {
+    const dialog = this.get(sessionId, toolCallId);
+    if (!dialog) return false;
+    clearTimeout(dialog.timer);
+    this.bySession.get(sessionId)?.delete(toolCallId);
+    dialog.resolve(answer);
+    return true;
+  }
+  /**
+  * Cancel a pending dialog, emitting a `tool-Question` cancellation frame so
+  * connected/replaying UIs can clear the question card.
+  */
+  cancel(sessionId, toolCallId, reason) {
+    const dialog = this.get(sessionId, toolCallId);
+    if (!dialog) return false;
+    clearTimeout(dialog.timer);
+    this.bySession.get(sessionId)?.delete(toolCallId);
+    const frame = {
+      type: "tool",
+      part: {
+        type: "tool-Question",
+        toolCallId,
+        state: "output-error",
+        output: {
+          cancelled: true,
+          reason,
+          title: dialog.title
+        }
+      }
+    };
+    this.emitFrame(sessionId, frame);
+    dialog.reject(/* @__PURE__ */ new Error(`Question cancelled: ${reason}`));
+    return true;
+  }
+  /** Cancel every pending dialog in a session (used by `abort` and shutdown). */
+  cancelAll(sessionId, reason) {
+    const pending = this.list(sessionId);
+    for (const dialog of pending) {
+      if (this.bySession.get(sessionId)?.get(dialog.toolCallId) === void 0) continue;
+      this.cancel(sessionId, dialog.toolCallId, reason);
+    }
+    return pending.length;
+  }
+  forSession(sessionId) {
+    let existing = this.bySession.get(sessionId);
+    if (!existing) {
+      existing = /* @__PURE__ */ new Map();
+      this.bySession.set(sessionId, existing);
+    }
+    return existing;
+  }
+};
+var RingBuffer = class {
+  entries = [];
+  capacity;
+  nextSeq = 1;
+  generation = crypto.randomUUID();
+  constructor(capacity = 500) {
+    this.capacity = Math.max(1, capacity);
+  }
+  get streamGeneration() {
+    return this.generation;
+  }
+  push(event, decorate) {
+    const seq = this.nextSeq++;
+    const entry = {
+      seq,
+      event: decorate ? decorate(seq, this.generation) : event
+    };
+    this.entries.push(entry);
+    if (this.entries.length > this.capacity) this.entries.splice(0, this.entries.length - this.capacity);
+    return entry;
+  }
+  /**
+  * Replay entries with seq > `lastEventId`. If `lastEventId` is behind the
   * oldest retained entry or ahead of the current sequence (for example after a
   * process restart), return `{ replayed, overflowed: true }` so the caller
   * emits a resync frame and instructs the client to rehydrate.
@@ -8198,21 +8807,32 @@ var PrimeBridge = class {
   }
   async setModel(sessionId, model) {
     const session = this.#requireSession(sessionId);
-    if (getPrimeConfig().modelRegistry.find(model.provider, model.id)) {
+    const catalog = await readDaemonModelCatalog(session.cwd).catch((error) => {
+      process.stderr.write(`[bridge:${sessionId.slice(0, 8)}] model catalog unavailable, passing ${model.provider}/${model.id} through: ${error instanceof Error ? error.message : String(error)}
+`);
+    });
+    if (!catalog) {
+      await session.connection.setModel(model.provider, model.id);
+      return {
+        provider: model.provider,
+        id: model.id
+      };
+    }
+    if (catalogHasModel(catalog, model.provider, model.id)) {
       await session.connection.setModel(model.provider, model.id);
       return {
         provider: model.provider,
         id: model.id
       };
     }
-    const fallback = getPrimeConfig().modelRegistry.getAvailable().find((candidate) => candidate.provider === model.provider);
+    const fallback = firstAvailableModelId(catalog, await providerAvailability(getPrimeConfig().agentDir), model.provider);
     if (!fallback) throw new Error(`Unknown model: ${model.provider}/${model.id}`);
-    process.stderr.write(`[bridge:${sessionId.slice(0, 8)}] model fallback ${model.provider}/${model.id} -> ${fallback.provider}/${fallback.id}
+    process.stderr.write(`[bridge:${sessionId.slice(0, 8)}] model fallback ${model.provider}/${model.id} -> ${model.provider}/${fallback}
 `);
-    await session.connection.setModel(fallback.provider, fallback.id);
+    await session.connection.setModel(model.provider, fallback);
     return {
-      provider: fallback.provider,
-      id: fallback.id
+      provider: model.provider,
+      id: fallback
     };
   }
   async setThinkingLevel(level) {
@@ -9765,238 +10385,32 @@ function fleetSettingsPath(agentDir) {
 async function readFleetSettings(agentDir) {
   try {
     return {
-      version: 1,
-      composerIntentEnabled: JSON.parse(await readFile(fleetSettingsPath(agentDir), "utf8")).composerIntentEnabled === true
-    };
-  } catch {
-    return { ...DEFAULT_FLEET_SETTINGS };
-  }
-}
-var writeChain = Promise.resolve();
-async function updateFleetSettings(agentDir, patch) {
-  const update = writeChain.then(() => writeFleetSettings(agentDir, patch));
-  writeChain = update.catch(() => void 0);
-  return update;
-}
-async function writeFleetSettings(agentDir, patch) {
-  const current = await readFleetSettings(agentDir);
-  const next = {
-    version: 1,
-    composerIntentEnabled: patch.composerIntentEnabled ?? current.composerIntentEnabled
-  };
-  const path = fleetSettingsPath(agentDir);
-  await mkdir(dirname(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  await writeFile(temporary, `${JSON.stringify(next, null, "	")}
-`, "utf8");
-  await rename(temporary, path);
-  return next;
-}
-var LOCK_TIMEOUT_MS = 5e3;
-var LOCK_RETRY_MS = 25;
-function isJsonObject$2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function errorCode(error) {
-  return isJsonObject$2(error) && typeof error.code === "string" ? error.code : void 0;
-}
-async function readJsonObjectFile(path) {
-  let raw;
-  try {
-    raw = await readFile(path, "utf8");
-  } catch (error) {
-    if (errorCode(error) === "ENOENT") return { kind: "missing" };
-    return {
-      kind: "invalid",
-      error: error instanceof Error ? error.message : "unreadable"
-    };
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!isJsonObject$2(parsed)) return {
-      kind: "invalid",
-      error: "expected a JSON object"
-    };
-    return {
-      kind: "ok",
-      value: parsed
-    };
-  } catch (error) {
-    return {
-      kind: "invalid",
-      error: error instanceof Error ? error.message : "invalid JSON"
-    };
-  }
-}
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return errorCode(error) === "EPERM";
-  }
-}
-async function acquireLock(lockPath) {
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-  await mkdir(dirname(lockPath), { recursive: true });
-  for (; ; ) try {
-    const descriptor = openSync(lockPath, "wx", 384);
-    writeFileSync(descriptor, String(process.pid), "utf8");
-    closeSync(descriptor);
-    return { release: () => {
-      rmSync(lockPath, { force: true });
-    } };
-  } catch (error) {
-    if (errorCode(error) !== "EEXIST") throw error;
-    let raw;
-    try {
-      const reader = openSync(lockPath, "r");
-      try {
-        raw = readFileSync(reader, "utf8");
-      } finally {
-        closeSync(reader);
-      }
-    } catch (readError) {
-      if (errorCode(readError) === "ENOENT") continue;
-      throw readError;
-    }
-    const holder = Number.parseInt(raw, 10);
-    if (!isProcessAlive(holder)) {
-      rmSync(lockPath, { force: true });
-      continue;
-    }
-    if (Date.now() >= deadline) throw new Error(`Timed out waiting for another Fleet write (held by process ${Number.isNaN(holder) ? "unknown" : holder}).`);
-    await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MS));
-  }
-}
-function currentMode(path) {
-  try {
-    return statSync(path).mode & 511;
-  } catch {
-    return;
-  }
-}
-async function writeJsonObjectFile(path, value, options = {}) {
-  await mkdir(dirname(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
-  const mode = currentMode(path) ?? options.mode ?? 420;
-  try {
-    await writeFile(temporary, `${JSON.stringify(value, null, "	")}
-`, {
-      encoding: "utf8",
-      mode
-    });
-    await chmod(temporary, mode);
-    await rename(temporary, path);
-  } catch (error) {
-    await rm(temporary, { force: true });
-    throw error;
-  }
-}
-var UnwritablePathError = class extends Error {
-  path;
-  cause;
-  constructor(path, cause) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    super(`${path}: ${detail}`);
-    this.path = path;
-    this.cause = cause;
-    this.name = "UnwritablePathError";
-  }
-};
-async function updateJsonObjectFile(path, mutate, options = {}) {
-  const lock = await acquireLock(`${path}.lock`).catch((error) => {
-    throw new UnwritablePathError(path, error);
-  });
-  try {
-    const current = await readJsonObjectFile(path);
-    if (current.kind === "invalid") return {
-      status: "refused",
-      reason: `${path} is not a readable JSON object: ${current.error}`
-    };
-    const outcome = mutate(current.kind === "ok" ? current.value : {});
-    if ("refuse" in outcome) return {
-      status: "refused",
-      reason: outcome.refuse
-    };
-    try {
-      await writeJsonObjectFile(path, outcome.next, options);
-    } catch (error) {
-      throw new UnwritablePathError(path, error);
-    }
-    return {
-      status: "written",
-      value: outcome.result
-    };
-  } finally {
-    lock.release();
-  }
-}
-var AUTH_FILE = "auth.json";
-function isJsonObject$1(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function authFilePath(agentDir) {
-  return join(agentDir, AUTH_FILE);
-}
-function isWritableProviderId(providerId) {
-  return providerId.length > 0 && providerId.length <= 128 && !/[\u0000-\u001f/\\]/.test(providerId);
-}
-async function readProviderApiKey(agentDir, providerId) {
-  const current = await readJsonObjectFile(authFilePath(agentDir));
-  if (current.kind !== "ok") return void 0;
-  const entry = current.value[providerId];
-  if (!isJsonObject$1(entry) || entry.type !== "api_key") return void 0;
-  const key = entry.key;
-  return typeof key === "string" ? key : void 0;
-}
-async function setProviderApiKey(agentDir, providerId, key) {
-  if (!isWritableProviderId(providerId)) return {
-    status: "refused",
-    reason: `"${providerId}" is not a valid provider id.`
-  };
-  const trimmed = key.trim();
-  if (trimmed.length === 0) return {
-    status: "refused",
-    reason: "The API key is empty."
-  };
-  const outcome = await updateJsonObjectFile(authFilePath(agentDir), (current) => {
-    const existing = current[providerId];
-    const next = {
-      ...isJsonObject$1(existing) ? existing : {},
-      type: "api_key",
-      key: trimmed
-    };
-    return {
-      next: {
-        ...current,
-        [providerId]: next
-      },
-      result: true
+      version: 1,
+      composerIntentEnabled: JSON.parse(await readFile(fleetSettingsPath(agentDir), "utf8")).composerIntentEnabled === true
     };
-  }, { mode: 384 });
-  return outcome.status === "refused" ? outcome : { status: "written" };
+  } catch {
+    return { ...DEFAULT_FLEET_SETTINGS };
+  }
 }
-async function configuredProviderIds(agentDir) {
-  const current = await readJsonObjectFile(authFilePath(agentDir));
-  if (current.kind !== "ok") return /* @__PURE__ */ new Set();
-  return new Set(Object.entries(current.value).filter(([, value]) => isJsonObject$1(value)).map(([providerId]) => providerId));
+var writeChain = Promise.resolve();
+async function updateFleetSettings(agentDir, patch) {
+  const update = writeChain.then(() => writeFleetSettings(agentDir, patch));
+  writeChain = update.catch(() => void 0);
+  return update;
 }
-async function removeProviderCredential(agentDir, providerId) {
-  const outcome = await updateJsonObjectFile(authFilePath(agentDir), (current) => {
-    if (!(providerId in current)) return {
-      next: current,
-      result: "absent"
-    };
-    const next = {};
-    for (const [currentId, value] of Object.entries(current)) if (currentId !== providerId) next[currentId] = value;
-    return {
-      next,
-      result: "removed"
-    };
-  }, { mode: 384 });
-  return outcome.status === "refused" ? outcome : { status: "written" };
+async function writeFleetSettings(agentDir, patch) {
+  const current = await readFleetSettings(agentDir);
+  const next = {
+    version: 1,
+    composerIntentEnabled: patch.composerIntentEnabled ?? current.composerIntentEnabled
+  };
+  const path = fleetSettingsPath(agentDir);
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(next, null, "	")}
+`, "utf8");
+  await rename(temporary, path);
+  return next;
 }
 var TYPESAFE_CREDENTIAL_ID = "typesafe";
 async function readStoredTypeSafeKey() {
@@ -18238,7 +18652,7 @@ function handleChatMcpOAuthPost(request, deps = defaultMcpDeps()) {
     if ((body.action ?? "login") === "logout") return Response.json(await logoutMcp(body.name, deps));
     return Response.json({
       status: "error",
-      error: "MCP OAuth sign-in is unavailable in Fleet settings. Launch Prime Agent in a terminal using the same configuration directory as Fleet and complete MCP sign-in there. Restart Fleet afterward to reload the credentials."
+      error: `Sign-in for ${body.name} has to run inside Prime Agent. In a terminal, start Prime Agent against the same account as Fleet, then run /mcp login ${body.name}. Fleet picks the credential up on its next refresh. If Fleet uses a non-default account directory, start Prime Agent with the same PRIME_AGENT_CODING_AGENT_DIR it uses.`
     }, { status: 501 });
   }, request);
 }
@@ -18257,25 +18671,17 @@ function handleChatMcpTokenPost(request, deps = defaultMcpDeps()) {
     });
   }, request);
 }
-var THINKING_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-var EXPLICIT_ONLY_LEVELS = /* @__PURE__ */ new Set(["xhigh", "max"]);
-function supportedThinkingLevels(model) {
-  if (!model.reasoning) return ["off"];
-  const map = model.thinkingLevelMap;
-  return THINKING_LEVELS.filter((level) => {
-    const mapped = map?.[level];
-    if (mapped === null) return false;
-    if (EXPLICIT_ONLY_LEVELS.has(level)) return mapped !== void 0;
-    return true;
-  });
+function defaultChatModelsDeps() {
+  const config = getPrimeConfig();
+  return {
+    resolveCwd: cwdForRequest,
+    agentDir: config.agentDir,
+    modelsJsonPath: `${config.agentDir}/models.json`,
+    readCatalog: readDaemonModelCatalog,
+    providerAvailability: (agentDir) => providerAvailability(agentDir),
+    settingsFor: (cwd) => config.settingsFor(cwd),
+    customProvidersMissingApiKey: providersMissingApiKey
+  };
 }
 function toPatternCandidate(model) {
   return {
@@ -18283,46 +18689,31 @@ function toPatternCandidate(model) {
     name: model.name,
     provider: model.provider,
     modelId: model.id,
-    key: `${model.provider}/${model.id}`
+    key: model.key
   };
 }
-function isWorkingConfiguredModel(registry, model) {
-  return registry.getProviderAuthStatus(model.provider).configured && registry.hasConfiguredAuth(model);
+function customProviderDiagnostics(modelsJsonPath, offenders) {
+  if (offenders.length === 0) return [];
+  const label = safePathLabel(modelsJsonPath);
+  return offenders.map((providerId) => `Provider ${providerId} in ${label} has no apiKey, so none of your custom providers can load. Add a non-empty "apiKey" to ${providerId} in models.json to fix it.`);
 }
-function handleChatModelsGet(request) {
+function handleChatModelsGet(request, deps = defaultChatModelsDeps()) {
   return wrapApiHandler(async () => {
-    const config = getPrimeConfig();
-    const cwd = await cwdForRequest(request);
-    const settings = config.settingsFor(cwd);
-    const registry = config.modelRegistry;
+    const cwd = await deps.resolveCwd(request);
+    const settings = deps.settingsFor(cwd);
     const scope = new URL(request.url).searchParams.get("scope") === "all" ? "all" : "enabled";
+    const isProviderAvailable = await deps.providerAvailability(deps.agentDir);
+    let models = toChatModelInfoList(await deps.readCatalog(cwd), isProviderAvailable);
     const patterns = settings.getEnabledModels();
-    let models = registry.getAll();
-    if (scope === "enabled") models = models.filter((model) => isWorkingConfiguredModel(registry, model) && isModelPatternEnabled(toPatternCandidate(model), patterns));
-    const diagnostics = [];
+    if (scope === "enabled") models = models.filter((model) => model.available && isModelPatternEnabled(toPatternCandidate(model), patterns));
+    const diagnostics = customProviderDiagnostics(deps.modelsJsonPath, deps.customProvidersMissingApiKey(deps.modelsJsonPath));
     const defaultProvider = settings.getDefaultProvider();
     const defaultModel = settings.getDefaultModel();
     const defaultThinkingLevel = settings.getDefaultThinkingLevel();
     const candidateModelKey = defaultProvider && defaultModel ? `${defaultProvider}/${defaultModel}` : void 0;
-    const selectedModelKey = candidateModelKey && models.some((m) => `${m.provider}/${m.id}` === candidateModelKey) ? candidateModelKey : models[0] ? `${models[0].provider}/${models[0].id}` : void 0;
+    const selectedModelKey = candidateModelKey && models.some((m) => m.key === candidateModelKey) ? candidateModelKey : models[0]?.key;
     return Response.json({
-      models: models.map((m) => {
-        const thinkingLevels = supportedThinkingLevels(m);
-        const fallback = m.reasoning ? "medium" : "off";
-        return {
-          key: `${m.provider}/${m.id}`,
-          provider: m.provider,
-          id: m.id,
-          name: m.name,
-          reasoning: m.reasoning,
-          input: m.input,
-          contextWindow: m.contextWindow,
-          maxTokens: m.maxTokens,
-          available: isWorkingConfiguredModel(registry, m),
-          thinkingLevels,
-          defaultThinkingLevel: thinkingLevels.includes(fallback) ? fallback : thinkingLevels[0] ?? "off"
-        };
-      }),
+      models,
       ...selectedModelKey ? { selectedModelKey } : {},
       ...defaultProvider ? { defaultProvider } : {},
       ...defaultModel ? { defaultModel } : {},
@@ -18331,180 +18722,6 @@ function handleChatModelsGet(request) {
     });
   }, request);
 }
-function storedApiForCustomProvider(api) {
-  return api === "google-genai" ? "google-generative-ai" : api;
-}
-function uiApiForCustomProvider(value) {
-  if (value === "google-generative-ai") return "google-genai";
-  return isPiCustomProviderApi(value) ? value : void 0;
-}
-function envVarNameForManagedProvider(providerId) {
-  if (providerId === "openai-chat-completions") return "OPENAI_CHAT_COMPLETIONS_API_KEY";
-  const slug = providerId.slice(providerId.indexOf("+") + 1).toUpperCase().replace(/[^A-Z0-9]+/g, "_");
-  return isOccProviderId(providerId) ? `OPENAI_CHAT_COMPLETIONS_${slug}_API_KEY` : `CUSTOM_${slug}_API_KEY`;
-}
-function readModelsJson(filePath) {
-  try {
-    if (!existsSync(filePath)) return {};
-    return parseModelsJson(readFileSync(filePath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function stripJsonComments(input) {
-  return input.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (match) => match[0] === '"' ? match : "").replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (match, tail) => tail ?? (match[0] === '"' ? match : ""));
-}
-function parseModelsJson(raw) {
-  const parsed = JSON.parse(stripJsonComments(raw));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("models.json must contain an object");
-  return parsed;
-}
-function readModelsJsonForWrite(filePath) {
-  if (!existsSync(filePath)) return {};
-  try {
-    return parseModelsJson(readFileSync(filePath, "utf-8"));
-  } catch (error) {
-    throw new Error(`Refusing to update models.json because it could not be parsed: ${error instanceof Error ? error.message : error}`);
-  }
-}
-var OPENAI_COMPLETIONS_TOOL_REASONING_NONE_PATTERN = /^(?:[^/]+\/)?gpt-(?:5[.-]6|6)(?:[.-]|$)/i;
-var OPENAI_COMPLETIONS_REASONING_OFF_MAP = {
-  off: "none",
-  minimal: null,
-  low: null,
-  medium: null,
-  high: null,
-  xhigh: null,
-  max: null
-};
-function applyModelDefaults(model, storedApi) {
-  if (storedApi === "openai-completions" && OPENAI_COMPLETIONS_TOOL_REASONING_NONE_PATTERN.test(model.id) && model.reasoning === void 0 && model.thinkingLevelMap === void 0) return {
-    ...model,
-    reasoning: true,
-    thinkingLevelMap: OPENAI_COMPLETIONS_REASONING_OFF_MAP
-  };
-  return model;
-}
-function mergeModelDefinitions(existing, incoming, storedApi) {
-  const existingById = new Map((existing ?? []).map((model) => [model.id, model]));
-  const seen = /* @__PURE__ */ new Set();
-  return incoming.flatMap((model) => {
-    if (seen.has(model.id)) return [];
-    seen.add(model.id);
-    return [applyModelDefaults({
-      ...existingById.get(model.id),
-      ...model
-    }, storedApi)];
-  });
-}
-function listCustomProviders(filePath) {
-  return readModelsJson(filePath).providers ?? {};
-}
-async function writeModelsJson(filePath, data) {
-  await writeJsonObjectFile(filePath, data, { mode: 420 });
-}
-function defaultCompatForCustomProvider(storedApi, baseUrl, existingCompat) {
-  const existingRecord = existingCompat && typeof existingCompat === "object" && !Array.isArray(existingCompat) ? existingCompat : void 0;
-  if (storedApi !== "openai-completions") return existingRecord;
-  try {
-    if (new URL(baseUrl).hostname === "api.openai.com") return existingRecord;
-  } catch {
-  }
-  return {
-    supportsStore: false,
-    ...existingRecord
-  };
-}
-async function upsertCustomProvider(filePath, providerId, input) {
-  const data = readModelsJsonForWrite(filePath);
-  const providers = { ...data.providers ?? {} };
-  const existing = providers[providerId] ?? {};
-  const storedApi = storedApiForCustomProvider(input.api);
-  const compat = defaultCompatForCustomProvider(storedApi, input.baseUrl, existing.compat);
-  providers[providerId] = {
-    ...existing,
-    name: input.name ?? existing.name,
-    baseUrl: input.baseUrl,
-    api: storedApi,
-    apiKey: input.apiKey,
-    ...compat ? { compat } : {},
-    models: mergeModelDefinitions(existing.models, input.models, storedApi)
-  };
-  await writeModelsJson(filePath, {
-    ...data,
-    providers
-  });
-}
-async function addCustomProviderModelIds(filePath, providerId, modelIds) {
-  const data = readModelsJsonForWrite(filePath);
-  const providers = { ...data.providers ?? {} };
-  const existing = providers[providerId];
-  if (!existing) return;
-  const compat = typeof existing.api === "string" && typeof existing.baseUrl === "string" ? defaultCompatForCustomProvider(existing.api, existing.baseUrl, existing.compat) : void 0;
-  providers[providerId] = {
-    ...existing,
-    ...compat ? { compat } : {},
-    models: mergeModelDefinitions(existing.models, [...existing.models ?? [], ...modelIds.map((id) => ({ id }))], existing.api)
-  };
-  await writeModelsJson(filePath, {
-    ...data,
-    providers
-  });
-}
-async function removeCustomProvider(filePath, providerId) {
-  const data = readModelsJsonForWrite(filePath);
-  const providers = data.providers;
-  if (!providers || !(providerId in providers)) return;
-  const next = { ...providers };
-  delete next[providerId];
-  await writeModelsJson(filePath, {
-    ...data,
-    providers: next
-  });
-}
-function isDiscoverableEntry(entry) {
-  const baseUrl = entry?.baseUrl;
-  if (!baseUrl) return false;
-  const api = uiApiForCustomProvider(entry?.api);
-  if (api && !isOccFamilyApi(api)) return false;
-  if (entry?.api && !api) return false;
-  try {
-    const parsed = new URL(baseUrl);
-    return parsed.protocol === "https:" || parsed.protocol === "http:";
-  } catch {
-    return false;
-  }
-}
-var PRIME_PROVIDER_ENV_MAP = {
-  openai: "OPENAI_API_KEY",
-  "azure-openai-responses": "AZURE_OPENAI_API_KEY",
-  "prime-inference": "PRIME_API_KEY",
-  deepseek: "DEEPSEEK_API_KEY",
-  google: "GEMINI_API_KEY",
-  "google-vertex": "GOOGLE_CLOUD_API_KEY",
-  groq: "GROQ_API_KEY",
-  cerebras: "CEREBRAS_API_KEY",
-  xai: "XAI_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
-  zai: "ZAI_API_KEY",
-  mistral: "MISTRAL_API_KEY",
-  minimax: "MINIMAX_API_KEY",
-  "minimax-cn": "MINIMAX_CN_API_KEY",
-  moonshotai: "MOONSHOT_API_KEY",
-  "moonshotai-cn": "MOONSHOT_API_KEY",
-  huggingface: "HF_TOKEN",
-  fireworks: "FIREWORKS_API_KEY",
-  opencode: "OPENCODE_API_KEY",
-  "opencode-go": "OPENCODE_API_KEY",
-  "kimi-coding": "KIMI_API_KEY",
-  "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
-  "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
-  xiaomi: "XIAOMI_API_KEY",
-  "xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
-  "xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
-  "xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
-};
 function providerEnvVarName(providerId) {
   return PRIME_PROVIDER_ENV_MAP[providerId];
 }
@@ -18520,6 +18737,7 @@ function openAiModelsUrl(baseUrl) {
   const parsed = new URL(baseUrl);
   if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new Error("model discovery requires an http(s) URL");
   if (parsed.protocol === "http:" && !isLoopbackHostname(parsed.hostname)) throw new Error("model discovery requires https for non-loopback hosts");
+  if (parsed.username || parsed.password) throw new Error("Credentials in model discovery URLs are not supported");
   const path = parsed.pathname.replace(/\/+$/, "");
   parsed.pathname = path.endsWith("/v1") ? `${path}/models` : `${path}/v1/models`;
   parsed.search = "";
@@ -18534,19 +18752,22 @@ function handleChatModelsDiscoverPost(request) {
     const apiKey = await resolveProviderApiKey(config.agentDir, body.providerId);
     if (!apiKey) return Response.json({
       providerId: body.providerId,
-      models: []
+      models: [],
+      error: "Model discovery is unavailable. Check provider configuration and try again."
     });
     const provider = body.providerId;
     const entry = listCustomProviders(`${config.agentDir}/models.json`)[provider];
     const api = uiApiForCustomProvider(entry?.api);
     if (entry?.api && !api || api && !isOccFamilyApi(api)) return Response.json({
       providerId: provider,
-      models: []
+      models: [],
+      error: "Model discovery is unavailable. Check provider configuration and try again."
     });
     const baseUrl = entry?.baseUrl;
     if (!baseUrl) return Response.json({
       providerId: provider,
-      models: []
+      models: [],
+      error: "Model discovery is unavailable. Check provider configuration and try again."
     });
     try {
       const modelsUrl = openAiModelsUrl(baseUrl);
@@ -18557,9 +18778,12 @@ function handleChatModelsDiscoverPost(request) {
       });
       if (!response.ok) return Response.json({
         providerId: provider,
-        models: []
+        models: [],
+        error: "Model discovery is unavailable. Check provider configuration and try again."
       });
-      const models = ((await response.json()).data ?? []).map((m) => ({
+      const payload = await response.json();
+      if (!Array.isArray(payload.data) || !payload.data.every((m) => typeof m?.id === "string" && m.id.length > 0)) throw new Error("Invalid model catalog");
+      const models = payload.data.map((m) => ({
         key: `${provider}/${m.id}`,
         provider,
         id: m.id,
@@ -18581,7 +18805,8 @@ function handleChatModelsDiscoverPost(request) {
     } catch {
       return Response.json({
         providerId: provider,
-        models: []
+        models: [],
+        error: "Could not refresh models. Previous results are retained; try again."
       });
     }
   }, request);
@@ -18687,46 +18912,32 @@ function handleChatPlanPresentationPut(request) {
     }) });
   }, request);
 }
-var BUILT_IN_PROVIDER_DISPLAY_NAMES = {
-  anthropic: "Anthropic",
-  "amazon-bedrock": "Amazon Bedrock",
-  "azure-openai-responses": "Azure OpenAI Responses",
-  cerebras: "Cerebras",
-  "cloudflare-ai-gateway": "Cloudflare AI Gateway",
-  "cloudflare-workers-ai": "Cloudflare Workers AI",
-  deepseek: "DeepSeek",
-  fireworks: "Fireworks",
-  google: "Google Gemini",
-  "google-vertex": "Google Vertex AI",
-  groq: "Groq",
-  huggingface: "Hugging Face",
-  "kimi-coding": "Kimi For Coding",
-  mistral: "Mistral",
-  minimax: "MiniMax",
-  "minimax-cn": "MiniMax (China)",
-  moonshotai: "Moonshot AI",
-  "moonshotai-cn": "Moonshot AI (China)",
-  opencode: "OpenCode Zen",
-  "opencode-go": "OpenCode Go",
-  openai: "OpenAI",
-  "openai-codex": "OpenAI Codex",
-  openrouter: "OpenRouter",
-  "prime-agent-traces": "Prime Agent Traces",
-  "prime-inference": "Prime Inference",
-  "vercel-ai-gateway": "Vercel AI Gateway",
-  xai: "xAI",
-  zai: "ZAI",
-  xiaomi: "Xiaomi MiMo",
-  "xiaomi-token-plan-cn": "Xiaomi MiMo Token Plan (China)",
-  "xiaomi-token-plan-ams": "Xiaomi MiMo Token Plan (Amsterdam)",
-  "xiaomi-token-plan-sgp": "Xiaomi MiMo Token Plan (Singapore)",
-  "github-copilot": "GitHub Copilot"
-};
 var KNOWN_PROVIDER_BY_ID = new Map(KNOWN_PROVIDERS.map((provider) => [provider.id, provider]));
 var EXTRA_BUILTIN_ENV_HINTS = {
   anthropic: "ANTHROPIC_API_KEY",
   "amazon-bedrock": "AWS_BEARER_TOKEN_BEDROCK"
 };
+var CREDENTIAL_QUERY_PARAMETER_NAMES = /* @__PURE__ */ new Set([
+  "auth",
+  "authorization",
+  "apikey",
+  "bearer",
+  "credential",
+  "credentials",
+  "key",
+  "pass",
+  "password",
+  "passwd",
+  "secret",
+  "sig",
+  "signature",
+  "token",
+  "jwt",
+  "assertion"
+]);
+function isCredentialQueryParameter(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).some((token) => CREDENTIAL_QUERY_PARAMETER_NAMES.has(token));
+}
 function envHintForBuiltin(providerId) {
   return PRIME_PROVIDER_ENV_MAP[providerId] ?? EXTRA_BUILTIN_ENV_HINTS[providerId] ?? "";
 }
@@ -18751,14 +18962,26 @@ var BUILTIN_OAUTH_PROVIDER_IDS = [
   "openai-codex",
   "xai"
 ];
-function isLlmsProviderId(providerId) {
-  return providerId !== "prime-agent-traces";
+function browserProviderBaseUrl(baseUrl) {
+  if (!baseUrl) return void 0;
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return void 0;
+    const credentialParameters = [...parsed.searchParams.keys()].filter(isCredentialQueryParameter);
+    if (!parsed.username && !parsed.password && credentialParameters.length === 0) return baseUrl;
+    parsed.username = "";
+    parsed.password = "";
+    for (const name of credentialParameters) parsed.searchParams.delete(name);
+    return parsed.toString();
+  } catch {
+    return;
+  }
 }
 function buildProviders(configuredFromDisk) {
   const config = getPrimeConfig();
   const oauthIds = new Set(BUILTIN_OAUTH_PROVIDER_IDS);
   const custom2 = listCustomProviders(`${config.agentDir}/models.json`);
-  const builtinIds = new Set(Object.keys(BUILT_IN_PROVIDER_DISPLAY_NAMES).filter(isLlmsProviderId));
+  const builtinIds = new Set(builtInProviderIds());
   const allIds = /* @__PURE__ */ new Set([...builtinIds, ...Object.keys(custom2)]);
   for (const providerId of configuredFromDisk ?? []) if (!providerId.startsWith("mcp:")) allIds.add(providerId);
   allIds.add(OPENAI_CHAT_COMPLETIONS_PROVIDER_ID);
@@ -18768,7 +18991,7 @@ function buildProviders(configuredFromDisk) {
     const configured = configuredFromDisk?.has(id) ?? false;
     const catalogEntry = KNOWN_PROVIDER_BY_ID.get(id);
     const name = isCustom ? customEntry?.name ?? catalogEntry?.name ?? id : BUILT_IN_PROVIDER_DISPLAY_NAMES[id] ?? catalogEntry?.name ?? id;
-    const envVarName = isCustom ? customEntry?.apiKey ?? catalogEntry?.envVarName ?? "" : envHintForBuiltin(id);
+    const envVarName = isCustom ? customEntry?.apiKey === envVarNameForManagedProvider(id) ? customEntry.apiKey : catalogEntry?.envVarName ?? "" : envHintForBuiltin(id);
     const row = {
       id,
       name,
@@ -18776,12 +18999,13 @@ function buildProviders(configuredFromDisk) {
       ...resolveProviderAuthFields(id, envVarName, oauthIds),
       isConfigured: configured
     };
-    if (isOccProviderId(id) || isCustomProviderId(id)) {
+    if (customEntry || isOccProviderId(id) || isCustomProviderId(id)) {
       row.providerFamily = isOccProviderId(id) ? OPENAI_CHAT_COMPLETIONS_PROVIDER_ID : "custom";
       if (customEntry?.name && (isNamedOccInstanceId(id) || isCustomProviderId(id))) row.displayName = customEntry.name;
       const customApi = uiApiForCustomProvider(customEntry?.api);
       if (customApi) row.api = customApi;
-      if (customEntry?.baseUrl) row.baseUrl = customEntry.baseUrl;
+      const baseUrl = browserProviderBaseUrl(customEntry?.baseUrl);
+      if (baseUrl) row.baseUrl = baseUrl;
       row.modelIds = (customEntry?.models ?? []).map((model) => model.id);
       row.discoverable = isDiscoverableEntry(customEntry);
     }
@@ -18799,6 +19023,7 @@ function requireBaseUrl(baseUrl, providerId) {
   if (!trimmed) badRequest(`baseUrl is required for ${providerId}`);
   try {
     const parsed = new URL(trimmed);
+    if (parsed.username || parsed.password || [...parsed.searchParams.keys()].some(isCredentialQueryParameter)) badRequest("baseUrl must not contain credentials; use the API key field instead");
     if (parsed.protocol !== "https:" && parsed.protocol !== "http:") badRequest(`baseUrl must be an http(s) URL for ${providerId}`);
   } catch (error) {
     if (error && typeof error === "object" && "status" in error) throw error;
@@ -18828,7 +19053,7 @@ function handleChatProvidersPost(request) {
     if (isNewCustom || isNewOccInstance) {
       const displayName2 = body.displayName?.trim() ?? "";
       if (!displayName2) badRequest("displayName is required when creating a new provider instance");
-      const existingIds = /* @__PURE__ */ new Set([...Object.keys(BUILT_IN_PROVIDER_DISPLAY_NAMES).filter(isLlmsProviderId), ...Object.keys(listCustomProviders(modelsJsonPath))]);
+      const existingIds = /* @__PURE__ */ new Set([...builtInProviderIds(), ...Object.keys(listCustomProviders(modelsJsonPath))]);
       providerId = allocateProviderId(toInstanceSlug(displayName2), existingIds, isNewCustom ? toCustomProviderId : toOccInstanceId);
     }
     const existingEntry = listCustomProviders(modelsJsonPath)[providerId];
@@ -18877,7 +19102,7 @@ function handleChatProvidersOAuthPost(request) {
     ChatProviderOAuthLoginRequestSchema.parse(await request.json().catch(() => ({})));
     return Response.json({
       status: "error",
-      error: "Provider OAuth sign-in is unavailable in Fleet settings. Launch Prime Agent in a terminal using the same configuration directory as Fleet and complete provider sign-in there. Restart Fleet afterward to reload the credentials."
+      error: "Sign-in has to run inside Prime Agent. In a terminal, start Prime Agent against the same account as Fleet, then run /login and choose the provider. Fleet reads the stored credential on every request. If Fleet uses a non-default account directory, start Prime Agent with the same PRIME_AGENT_CODING_AGENT_DIR it uses."
     }, { status: 501 });
   }, request);
 }
@@ -19465,6 +19690,7 @@ function handleChatSettingsPatch(request) {
       code: "UNWRITABLE",
       message: `Fleet could not update ${safePathLabel(path)}. ${outcome.reason} Change these settings in the Prime Agent terminal interface instead.`
     }, { status: 409 });
+    getPrimeConfig().invalidateSettings();
     if (outcome.impact.resourceReloadRequired) await getBridge().reloadResources().catch(() => void 0);
     const response = await buildResponse(cwd);
     return Response.json({