@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/{chunk-QKIFBZKT.js → chunk-VW6DOEDG.js}

@@ -1,12 +1,16 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   THINKING_LEVELS
-} from "./chunk-BWW4HLO4.js";
+} from "./chunk-UXCU4E3T.js";
 import {
+  runCommandVector
+} from "./chunk-JSC3U7TI.js";
+import {
+  catalogThinkingLevelsForRuntime,
   listCatalogModelsForRuntime,
   mergeCapabilities,
   synthesizeCatalogBackedModel
-} from "./chunk-O42A54GG.js";
+} from "./chunk-5OIVVPHF.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -16,47 +20,243 @@ init_esm_shims();
 
 // src/domains/providers/runtimes/antigravity/antigravity-code.ts
 init_esm_shims();
-var ANTIGRAVITY_AUTH_NOTICE = "Uses your existing Antigravity (`agy`) login. Clio stores no Antigravity credentials. agy runs its own agent harness as a subprocess; Clio maps autonomy levels onto its CLI flags but cannot mediate individual agy tool calls.";
+
+// src/core/external-diagnostic.ts
+init_esm_shims();
+var REDACTED = "[redacted]";
+function redactExternalDiagnostic(input) {
+  return input.replace(/\b(?:authorization|proxy-authorization)\s*:\s*[^\r\n]+/giu, `Authorization: ${REDACTED}`).replace(/\b(?:set-cookie|cookie)\s*:\s*[^\r\n]+/giu, `Cookie: ${REDACTED}`).replace(/\bbearer\s+[A-Za-z0-9._~+/-]+=*/giu, `Bearer ${REDACTED}`).replace(
+    /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)\s*[:=]\s*[^\s,;]+/giu,
+    (match) => {
+      const separator = match.includes(":") ? ":" : "=";
+      return `${match.slice(0, match.indexOf(separator)).trim()}${separator}${REDACTED}`;
+    }
+  ).replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, REDACTED).replace(
+    /(?:~|\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*)\/\.(?:gemini\/antigravity-cli|antigravitycli)(?:\/[^\s]*)?/gu,
+    "[redacted credential path]"
+  ).replace(/https?:\/\/[^\s"'<>]+/giu, (url2) => {
+    try {
+      const parsed = new URL(url2);
+      if (/(?:auth|oauth|login|signin|callback)/iu.test(parsed.pathname)) return "[redacted authorization URL]";
+      parsed.username = "";
+      parsed.password = "";
+      parsed.search = "";
+      parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return REDACTED;
+    }
+  });
+}
+function boundedExternalDiagnostic(input, maxBytes = 8192) {
+  const redacted = redactExternalDiagnostic(input).trim();
+  const bytes = Buffer.from(redacted, "utf8");
+  if (bytes.byteLength <= maxBytes) return redacted;
+  return `${bytes.subarray(0, Math.max(0, maxBytes - 32)).toString("utf8")}
+[diagnostic truncated]`;
+}
+
+// src/domains/providers/runtimes/antigravity/antigravity-code.ts
+var ANTIGRAVITY_AUTH_NOTICE = "Experimental local delegation through your installed Antigravity (`agy`) CLI. Clio neither signs in nor stores or inspects Antigravity credentials. Run `agy` yourself and complete sign-in before probing this target.";
 var ANTIGRAVITY_MODELS = [
-  "Gemini 3.5 Flash (High)",
-  "Gemini 3.5 Flash (Medium)",
-  "Gemini 3.5 Flash (Low)",
-  "Gemini 3.1 Pro (High)",
-  "Gemini 3.1 Pro (Low)",
-  "Claude Sonnet 4.6 (Thinking)",
-  "Claude Opus 4.6 (Thinking)",
-  "GPT-OSS 120B (Medium)"
+  "gemini-3.8-flash-high",
+  "gemini-3.8-flash-medium",
+  "gemini-3.8-flash-low",
+  "gemini-3.1-pro-high",
+  "gemini-3.1-pro-low"
 ];
 var antigravityCapabilities = {
   chat: true,
-  tools: true,
-  toolCallFormat: "openai",
-  reasoning: true,
-  vision: true,
+  tools: false,
+  reasoning: false,
+  vision: false,
   audio: false,
   embeddings: false,
   rerank: false,
   fim: false,
-  contextWindow: 1e6,
-  maxTokens: 8192
+  contextWindow: 0,
+  maxTokens: 0
+};
+var ANTIGRAVITY_MAX_CATALOG_BYTES = 1024 * 1024;
+var ANTIGRAVITY_MAX_DISCOVERED_MODELS = 4096;
+var MAX_MODEL_ID_CHARS = 1024;
+var MAX_MODEL_LABEL_CHARS = 1024;
+var AntigravityCatalogError = class extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.name = "AntigravityCatalogError";
+    this.kind = kind;
+  }
 };
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function parseAntigravityModelCatalogDetails(output) {
+  let decoded;
+  try {
+    decoded = JSON.parse(output);
+  } catch {
+    throw new AntigravityCatalogError(
+      "unsupported-feature",
+      "agy returned an unreadable model catalog; update the Antigravity CLI and retry"
+    );
+  }
+  const envelope = record(decoded);
+  const command = record(envelope?.command);
+  const data = record(command?.data);
+  if (envelope?.status !== "SUCCESS") {
+    const detail = boundedExternalDiagnostic(
+      typeof envelope?.error === "string" ? envelope.error : typeof command?.error === "string" ? command.error : "agy could not list models"
+    );
+    const kind = classifyAntigravityDiagnostic(detail);
+    throw new AntigravityCatalogError(kind, antigravityProbeMessage(kind, detail));
+  }
+  if (command?.name !== "models" || !Array.isArray(data?.models)) {
+    throw new AntigravityCatalogError(
+      "unsupported-feature",
+      "agy returned an unsupported model catalog; update the Antigravity CLI and retry"
+    );
+  }
+  if (data.models.length === 0) {
+    throw new AntigravityCatalogError(
+      "catalog-unavailable",
+      "agy returned no available models; run `agy` locally and verify the signed-in account has model access"
+    );
+  }
+  if (data.models.length > ANTIGRAVITY_MAX_DISCOVERED_MODELS) {
+    throw new AntigravityCatalogError(
+      "catalog-unavailable",
+      `agy returned more than ${ANTIGRAVITY_MAX_DISCOVERED_MODELS} models; the authoritative catalog was refused rather than truncated`
+    );
+  }
+  const models = [];
+  const labels = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of data.models) {
+    const model = record(value);
+    const id = typeof model?.id === "string" ? model.id.trim() : "";
+    const label = typeof model?.label === "string" ? model.label.trim() : "";
+    if (id.length === 0 || id.length > MAX_MODEL_ID_CHARS || /[\r\n\0]/u.test(id)) {
+      throw new AntigravityCatalogError("catalog-unavailable", "agy returned an invalid model identifier");
+    }
+    if (label.length === 0 || label.length > MAX_MODEL_LABEL_CHARS || /[\r\n\0]/u.test(label)) {
+      throw new AntigravityCatalogError("catalog-unavailable", `agy returned an invalid label for model '${id}'`);
+    }
+    if (seen.has(id)) {
+      if (labels[id] !== label) {
+        throw new AntigravityCatalogError(
+          "catalog-unavailable",
+          `agy returned conflicting labels for duplicate model '${id}'`
+        );
+      }
+      continue;
+    }
+    seen.add(id);
+    models.push(id);
+    labels[id] = label;
+  }
+  return { models, labels };
+}
+function classifyAntigravityDiagnostic(detail) {
+  if (/(?:enoent|not found|cannot find|could not start|spawn .*agy)/iu.test(detail)) return "missing";
+  if (/(?:sign[ -]?in|log[ -]?in|unauthori[sz]ed|authenticat|credential|account.*required)/iu.test(detail)) {
+    return "authentication";
+  }
+  if (/(?:unknown|unsupported|unrecognized|invalid) (?:option|argument|command)|output-format|models command/iu.test(detail)) {
+    return "unsupported-feature";
+  }
+  return "generic";
+}
+function antigravityProbeMessage(kind, detail) {
+  const safeDetail = boundedExternalDiagnostic(detail || "no diagnostic was provided");
+  switch (kind) {
+    case "missing":
+      return "Antigravity CLI is not installed or `agy` is not on PATH";
+    case "authentication":
+      return `Antigravity sign-in is required; run \`agy\` yourself and complete sign-in (${safeDetail})`;
+    case "unsupported-feature":
+      return `the installed Antigravity CLI does not expose the required structured model catalog; update \`agy\` (${safeDetail})`;
+    case "catalog-unavailable":
+      return safeDetail;
+    case "cancelled":
+      return "Antigravity model discovery was cancelled";
+    default:
+      return `Antigravity model discovery failed: ${safeDetail}`;
+  }
+}
+async function probeAntigravityModelCatalog(ctx, runner = runCommandVector) {
+  const result = await runner("agy", ["--output-format", "json", "models"], {
+    cwd: process.cwd(),
+    workspaceRoot: process.cwd(),
+    timeoutMs: Math.max(1, ctx.httpTimeoutMs),
+    maxOutputBytes: ANTIGRAVITY_MAX_CATALOG_BYTES,
+    ...ctx.signal ? { signal: ctx.signal } : {}
+  });
+  if (result.aborted || result.timedOut) {
+    return {
+      ok: false,
+      latencyMs: result.durationMs,
+      failureKind: "cancelled",
+      error: antigravityProbeMessage("cancelled", "")
+    };
+  }
+  if (result.outputCapped) {
+    return {
+      ok: false,
+      latencyMs: result.durationMs,
+      failureKind: "catalog-unavailable",
+      error: `agy model catalog exceeded ${ANTIGRAVITY_MAX_CATALOG_BYTES} bytes`
+    };
+  }
+  if (result.exitCode !== 0) {
+    const detail = boundedExternalDiagnostic(result.stderr || result.stdout || `agy exited ${String(result.exitCode)}`);
+    const kind = classifyAntigravityDiagnostic(detail);
+    return { ok: false, latencyMs: result.durationMs, failureKind: kind, error: antigravityProbeMessage(kind, detail) };
+  }
+  try {
+    const catalog = parseAntigravityModelCatalogDetails(result.stdout);
+    return {
+      ok: true,
+      latencyMs: result.durationMs,
+      models: catalog.models,
+      modelLabels: catalog.labels
+    };
+  } catch (cause) {
+    const kind = cause instanceof AntigravityCatalogError ? cause.kind : "generic";
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    return { ok: false, latencyMs: result.durationMs, failureKind: kind, error: boundedExternalDiagnostic(detail) };
+  }
+}
 var antigravityCodeRuntime = {
   id: "antigravity-code",
-  displayName: "Antigravity CLI",
+  displayName: "Antigravity CLI \u2014 experimental local delegation",
   kind: "subprocess",
   tier: "subscription",
-  // Reuses the existing `google-generative-ai` api family: the worker branches
-  // to its own runner before any pi-ai inference, so this only needs to be a
-  // valid, google-backed family. The runner is selected by runtime id, and the
-  // plain-text parser is named by `outputParser`.
-  apiFamily: "google-generative-ai",
+  apiFamily: "external-agent-subprocess",
   auth: "none",
   authNotice: ANTIGRAVITY_AUTH_NOTICE,
   knownModels: [...ANTIGRAVITY_MODELS],
   binaryName: "agy",
-  headlessCommand: "agy --print",
-  outputParser: "antigravity-print-text",
+  headlessCommand: "agy --input-format stream-json --output-format stream-json",
+  outputParser: "antigravity-stream-json",
   defaultCapabilities: antigravityCapabilities,
+  externalAgentLoop: {
+    tools: "externally-governed-unobserved",
+    network: "externally-governed-unobserved",
+    budget: "external-one-shot",
+    generatingRetry: "forbidden",
+    modelCatalog: "live-authoritative"
+  },
+  async probe(_target, ctx) {
+    try {
+      return await probeAntigravityModelCatalog(ctx);
+    } catch (cause) {
+      const detail = boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
+      const kind = classifyAntigravityDiagnostic(detail);
+      return { ok: false, failureKind: kind, error: antigravityProbeMessage(kind, detail) };
+    }
+  },
   synthesizeModel(target, wireModelId, kb) {
     return synthesizeCatalogBackedModel({
       target,
@@ -64,9 +264,9 @@ var antigravityCodeRuntime = {
       kb,
       defaultCapabilities: antigravityCapabilities,
       runtimeId: "antigravity-code",
-      api: "google-generative-ai",
-      provider: "google",
-      defaultBaseUrl: "antigravity://local"
+      api: "external-agent-subprocess",
+      provider: "antigravity",
+      defaultBaseUrl: "external-agent://antigravity/local"
     });
   }
 };
@@ -257,15 +457,102 @@ init_esm_shims();
 
 // src/domains/providers/types/local-model-quirks.ts
 init_esm_shims();
-var KV_CACHE_QUANTS = ["f32", "f16", "q8_0", "q4_0", "q4_1", "iq4_nl", "q5_0", "q5_1"];
+
+// src/domains/providers/types/capability-flags.ts
+init_esm_shims();
+
+// src/domains/providers/model-family.ts
+init_esm_shims();
+function normalizeModelIdForFamily(modelId) {
+  return (modelId ?? "").trim().toLowerCase().replace(/_/g, "-");
+}
+function isHarmonyModelId(modelId) {
+  return normalizeModelIdForFamily(modelId).includes("gpt-oss");
+}
+function inferLocalModelFamily(modelId) {
+  const normalized = normalizeModelIdForFamily(modelId);
+  if (normalized.length === 0) return "unknown";
+  if (normalized.includes("gpt-oss")) return "openai-gpt-oss";
+  if (normalized.includes("nemotron-cascade-2") || normalized.includes("nemotron-cascade2")) {
+    return "nemotron-cascade-2";
+  }
+  if (normalized.includes("nemotron-3-nano-omni") || normalized.includes("nemotron-nano-omni")) {
+    return "nemotron-3-nano-omni";
+  }
+  if (normalized.includes("qwen3")) return "qwen3";
+  if (normalized.includes("gemma-4") || normalized.includes("gemma4") || normalized.includes("gemopus")) {
+    return "gemma-4";
+  }
+  return "unknown";
+}
+
+// src/domains/providers/types/capability-flags.ts
+var EMPTY_CAPABILITIES = {
+  chat: false,
+  tools: false,
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 0,
+  maxTokens: 0
+};
+var VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+var THINKING_LEVELS_WITHOUT_XHIGH = ["off", "minimal", "low", "medium", "high"];
+var THINKING_LEVELS_OPENAI_5_1_MINI = ["off", "minimal", "low", "medium", "high"];
+var THINKING_LEVELS_OPENAI_5_2_PLUS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var THINKING_LEVELS_OPENAI_5_6 = [...THINKING_LEVELS_OPENAI_5_2_PLUS, "max"];
+var THINKING_LEVELS_HARMONY = ["low", "medium", "high"];
+function normalizeModelId(modelId) {
+  if (!modelId) return void 0;
+  const trimmed = modelId.trim();
+  if (trimmed.length === 0) return void 0;
+  return trimmed.includes("/") ? trimmed.split("/").pop() ?? trimmed : trimmed;
+}
+function availableOpenAICodexThinkingLevels(modelId) {
+  const normalized = normalizeModelId(modelId);
+  if (!normalized) return VALID_THINKING_LEVELS;
+  if (normalized === "gpt-5.1-codex-mini") return THINKING_LEVELS_OPENAI_5_1_MINI;
+  if (normalized.startsWith("gpt-5.2") || normalized.startsWith("gpt-5.3") || normalized.startsWith("gpt-5.4") || normalized.startsWith("gpt-5.5")) {
+    return THINKING_LEVELS_OPENAI_5_2_PLUS;
+  }
+  if (normalized.startsWith("gpt-5.6")) {
+    return THINKING_LEVELS_OPENAI_5_6;
+  }
+  return THINKING_LEVELS_WITHOUT_XHIGH;
+}
+function availableThinkingLevels(caps, options) {
+  if (!caps.reasoning) return ["off"];
+  if (caps.thinkingFormat === "harmony" || isHarmonyModelId(options?.modelId)) {
+    return THINKING_LEVELS_HARMONY;
+  }
+  const catalogLevels = options?.runtimeId && options.modelId ? catalogThinkingLevelsForRuntime(options.runtimeId, options.modelId) : void 0;
+  if (catalogLevels) {
+    if (!catalogLevels.includes("xhigh")) return catalogLevels.filter((level) => level !== "max");
+    return catalogLevels;
+  }
+  if (caps.thinkingFormat === "openai-codex" || options?.runtimeId === "openai-codex") {
+    return availableOpenAICodexThinkingLevels(options?.modelId);
+  }
+  if (caps.thinkingFormat === "anthropic-extended") {
+    return THINKING_LEVELS_WITHOUT_XHIGH;
+  }
+  return THINKING_LEVELS_WITHOUT_XHIGH;
+}
+
+// src/domains/providers/types/local-model-quirks.ts
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function asKvCacheQuant(value) {
-  if (value === false) return false;
-  if (typeof value !== "string") return void 0;
-  return KV_CACHE_QUANTS.includes(value) ? value : void 0;
-}
 function asPositive(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
@@ -276,16 +563,6 @@ function asInteger(value) {
 function asPenalty(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function extractKvCache(raw) {
-  if (!isRecord(raw)) return void 0;
-  const out = {};
-  const k = asKvCacheQuant(raw.kQuant);
-  if (k !== void 0) out.kQuant = k;
-  const v = asKvCacheQuant(raw.vQuant);
-  if (v !== void 0) out.vQuant = v;
-  if (typeof raw.useFp16 === "boolean") out.useFp16 = raw.useFp16;
-  return Object.keys(out).length > 0 ? out : void 0;
-}
 function extractSamplingProfile(raw) {
   if (!isRecord(raw)) return void 0;
   const out = {};
@@ -303,8 +580,6 @@ function extractSamplingProfile(raw) {
   if (pp !== void 0) out.presencePenalty = pp;
   const fp = asPenalty(raw.frequencyPenalty);
   if (fp !== void 0) out.frequencyPenalty = fp;
-  const maxTokens = asInteger(raw.maxTokens);
-  if (maxTokens !== void 0) out.maxTokens = maxTokens;
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function extractSampling(raw) {
@@ -353,6 +628,61 @@ function extractEffortByLevel(raw) {
   if (typeof raw.xhigh === "string" && raw.xhigh.length > 0) out.xhigh = raw.xhigh;
   return Object.keys(out).length > 0 ? out : void 0;
 }
+function extractChatTemplateKwargs(raw) {
+  if (!isRecord(raw)) return void 0;
+  const out = {};
+  if (isRecord(raw.static)) {
+    const staticMap = {};
+    for (const [k, v] of Object.entries(raw.static)) {
+      if (typeof v === "boolean") {
+        staticMap[k] = v;
+      } else if (typeof v === "number" && Number.isFinite(v)) {
+        staticMap[k] = v;
+      } else if (typeof v === "string" && v.length > 0) {
+        staticMap[k] = v;
+      }
+    }
+    if (Object.keys(staticMap).length > 0) out.static = staticMap;
+  }
+  if (isRecord(raw.byLevel)) {
+    const byLevelRaw = raw.byLevel;
+    if (typeof byLevelRaw.key === "string" && byLevelRaw.key.trim().length > 0 && isRecord(byLevelRaw.values)) {
+      const values = {};
+      for (const level of VALID_THINKING_LEVELS) {
+        const val = byLevelRaw.values[level];
+        if (typeof val === "string" && val.length > 0) {
+          values[level] = val;
+        } else if (typeof val === "number" && Number.isFinite(val)) {
+          values[level] = val;
+        }
+      }
+      if (Object.keys(values).length > 0) {
+        const byLevel = {
+          key: byLevelRaw.key.trim(),
+          values
+        };
+        if (typeof byLevelRaw.lmstudio === "string" && byLevelRaw.lmstudio.trim().length > 0) {
+          byLevel.lmstudio = byLevelRaw.lmstudio.trim();
+        }
+        out.byLevel = byLevel;
+      }
+    }
+  }
+  if (typeof raw.lmstudio === "string" && raw.lmstudio.trim().length > 0) {
+    out.lmstudio = raw.lmstudio.trim();
+  } else if (isRecord(raw.lmstudio)) {
+    const lmstudioMap = {};
+    for (const [k, v] of Object.entries(raw.lmstudio)) {
+      if (typeof v === "string" && v.trim().length > 0) {
+        lmstudioMap[k] = v.trim();
+      }
+    }
+    if (Object.keys(lmstudioMap).length > 0) {
+      out.lmstudio = lmstudioMap;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function extractThinkingQuirks(raw) {
   if (!isRecord(raw)) return void 0;
   const mechanism = asThinkingMechanism(raw.mechanism);
@@ -363,17 +693,19 @@ function extractThinkingQuirks(raw) {
   const effortByLevel = extractEffortByLevel(raw.effortByLevel);
   if (effortByLevel) out.effortByLevel = effortByLevel;
   if (typeof raw.guidance === "string" && raw.guidance.length > 0) out.guidance = raw.guidance;
+  const chatTemplateKwargs = extractChatTemplateKwargs(raw.chatTemplateKwargs);
+  if (chatTemplateKwargs) out.chatTemplateKwargs = chatTemplateKwargs;
   return out;
 }
 function extractLocalModelQuirks(raw) {
   if (!isRecord(raw)) return void 0;
   const out = {};
-  const kvCache = extractKvCache(raw.kvCache);
-  if (kvCache) out.kvCache = kvCache;
   const sampling = extractSampling(raw.sampling);
   if (sampling) out.sampling = sampling;
   const thinking = extractThinkingQuirks(raw.thinking);
   if (thinking) out.thinking = thinking;
+  const chatTemplateKwargs = extractChatTemplateKwargs(raw.chatTemplateKwargs) ?? extractChatTemplateKwargs(isRecord(raw.thinking) ? raw.thinking.chatTemplateKwargs : void 0) ?? extractChatTemplateKwargs(isRecord(raw.request) ? raw.request.chatTemplateKwargs : void 0);
+  if (chatTemplateKwargs) out.chatTemplateKwargs = chatTemplateKwargs;
   return Object.keys(out).length > 0 ? out : void 0;
 }
 
@@ -444,7 +776,8 @@ function synthLocalModel(input) {
       ...target.gateway === true ? { gateway: true } : {},
       ...kb?.entry.family ? { family: kb.entry.family } : {},
       ...quirks ? { quirks } : {},
-      ...target.lmstudio ? { lmstudio: target.lmstudio } : {}
+      ...target.lmstudio ? { lmstudio: target.lmstudio } : {},
+      ...target.litellm ? { litellm: target.litellm } : {}
     }
   };
   if (headers) model.headers = headers;
@@ -617,41 +950,41 @@ function isRecord2(value) {
 function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-function firstPositiveNumber(record, keys) {
+function firstPositiveNumber(record2, keys) {
   for (const key of keys) {
-    const value = positiveNumber(record[key]);
+    const value = positiveNumber(record2[key]);
     if (value !== void 0) return value;
   }
   return void 0;
 }
-function capabilityListFlag(record, name) {
-  const list = record.capabilities;
+function capabilityListFlag(record2, name) {
+  const list = record2.capabilities;
   if (!Array.isArray(list)) return void 0;
   return list.some((entry) => entry === name) ? true : void 0;
 }
-function booleanFromAny(record, keys) {
+function booleanFromAny(record2, keys) {
   for (const key of keys) {
-    const value = record[key];
+    const value = record2[key];
     if (typeof value === "boolean") return value;
   }
   return void 0;
 }
-function nestedRecord(record, key) {
-  const value = record[key];
+function nestedRecord(record2, key) {
+  const value = record2[key];
   return isRecord2(value) ? value : null;
 }
-function firstString(record, keys) {
-  if (!record) return void 0;
+function firstString(record2, keys) {
+  if (!record2) return void 0;
   for (const key of keys) {
-    const value = record[key];
+    const value = record2[key];
     if (typeof value === "string" && value.trim().length > 0) return value.trim();
   }
   return void 0;
 }
-function firstBoolean(record, keys) {
-  if (!record) return void 0;
+function firstBoolean(record2, keys) {
+  if (!record2) return void 0;
   for (const key of keys) {
-    const value = record[key];
+    const value = record2[key];
     if (typeof value === "boolean") return value;
   }
   return void 0;
@@ -855,8 +1188,10 @@ async function probeLlamaCppModelStatus(base, target, ctx) {
   const entries = await probeOpenAIModelEntries(base, ctx);
   const selected = selectedModelEntry(entries, target);
   if (!selected) return {};
+  const loadState = modelStateFromOpenAIModelEntry({ id: selected.id, status: selected.status })?.state;
+  const withState = (enrichment2) => loadState === void 0 ? enrichment2 : { ...enrichment2, loadState };
   const args = argsFromStatus(selected.status);
-  if (args.length === 0) return { notes: statusNotes(selected.id, selected.status) };
+  if (args.length === 0) return withState({ notes: statusNotes(selected.id, selected.status) });
   const flags = parseLlamaCppServerFlags(args);
   const caps = {};
   const window = llamaCppRequestContextWindow(flags);
@@ -877,7 +1212,7 @@ async function probeLlamaCppModelStatus(base, target, ctx) {
     );
   }
   if (notes.length > 0) enrichment.notes = notes;
-  return enrichment;
+  return withState(enrichment);
 }
 async function detectModelMismatch(base, target, ctx) {
   const expected = target.defaultModel?.trim();
@@ -1797,7 +2132,8 @@ var llamacppRuntime = {
     const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
     if (!health.ok) return health;
     const status = await probeLlamaCppModelStatus(base, target, ctx);
-    const props = await probeLlamaCppProps(base, ctx, status.modelId ?? target.defaultModel);
+    const resident = status.loadState === void 0 || status.loadState === "loaded";
+    const props = await probeLlamaCppProps(base, ctx, resident ? status.modelId ?? target.defaultModel : void 0);
     const catalog = await probeOpenAIModelCatalog(base, ctx);
     const result = { ok: true };
     if (catalog.models.length > 0) result.models = catalog.models;
@@ -2542,8 +2878,8 @@ function lmStudioReasoningLevels(options) {
   return [...new Set(levels)];
 }
 function lmStudioReasoningEffort(level, options) {
+  if (options?.includes("on") && options.includes("off")) return level === "off" ? "none" : void 0;
   if (level === "off") return "none";
-  if (options?.includes("on") && !options.includes("medium") && !options.includes("high")) return "low";
   if (level === "medium" && options?.includes("medium") !== false) return "medium";
   if ((level === "high" || level === "xhigh" || level === "max") && options?.includes("high") !== false) return "high";
   return "low";
@@ -2982,7 +3318,7 @@ var defaultCapabilities25 = {
   embeddings: false,
   rerank: false,
   fim: false,
-  structuredOutputs: "json-schema",
+  structuredOutputs: "none",
   contextWindow: CLIO_MIN_CONTEXT_WINDOW,
   maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
 };
@@ -3007,6 +3343,8 @@ function boolean(value) {
 }
 function capabilitiesFromLiteLLMModelInfo(info) {
   const caps = {};
+  if (info.runtime === "lm-studio") caps.thinkingControlRuntime = "lmstudio";
+  else if (info.runtime === "llama.cpp") caps.thinkingControlRuntime = "llamacpp";
   const contextWindow = positiveInteger(info.max_input_tokens) ?? positiveInteger(info.max_tokens);
   if (contextWindow !== void 0) caps.contextWindow = contextWindow;
   const maxTokens = positiveInteger(info.max_output_tokens);
@@ -3028,36 +3366,96 @@ function capabilitiesFromLiteLLMModelInfo(info) {
     caps.rerank = true;
   }
   if (info.mode === "chat") caps.chat = true;
-  if (boolean(info.supports_response_schema) === true) caps.structuredOutputs = "json-schema";
+  const responseSchema = boolean(info.supports_response_schema);
+  if (responseSchema !== void 0) caps.structuredOutputs = responseSchema ? "json-schema" : "none";
   return caps;
 }
-var EMPTY_CATALOG = { models: [], modelCapabilities: {}, modelStates: {}, deployments: {} };
+var BOOLEAN_CAPABILITIES = [
+  "chat",
+  "tools",
+  "reasoning",
+  "vision",
+  "audio",
+  "embeddings",
+  "rerank",
+  "fim"
+];
+function aggregateLiteLLMCapabilities(rows) {
+  if (rows.length === 0) return {};
+  const aggregate = {};
+  for (const key of ["contextWindow", "maxTokens"]) {
+    const values = rows.map((row) => row[key]);
+    if (values.every((value) => typeof value === "number")) {
+      aggregate[key] = Math.min(...values);
+    }
+  }
+  for (const key of BOOLEAN_CAPABILITIES) {
+    const values = rows.map((row) => row[key]);
+    if (values.some((value) => value === false)) aggregate[key] = false;
+    else if (values.every((value) => value === true)) aggregate[key] = true;
+  }
+  const controlRuntime = rows[0]?.thinkingControlRuntime;
+  if (controlRuntime !== void 0 && rows.every((row) => row.thinkingControlRuntime === controlRuntime)) {
+    aggregate.thinkingControlRuntime = controlRuntime;
+  }
+  const structuredOutputs = rows.map((row) => row.structuredOutputs);
+  if (structuredOutputs.some((value) => value === "none")) aggregate.structuredOutputs = "none";
+  else if (structuredOutputs.every((value) => value === "json-schema")) aggregate.structuredOutputs = "json-schema";
+  return aggregate;
+}
+var EMPTY_CATALOG = {
+  models: [],
+  modelCapabilities: {},
+  modelStates: {},
+  deployments: {},
+  authFailed: false
+};
+function isAuthError(leg) {
+  return !leg.ok && /^HTTP 40[13]\b/u.test(leg.error ?? "");
+}
 async function fetchCatalog(base, ctx, headers) {
   const detailOpts = { url: `${base}/v1/model/info`, timeoutMs: ctx.httpTimeoutMs, headers };
   const detail = await (ctx.signal ? probeJson({ ...detailOpts, signal: ctx.signal }) : probeJson(detailOpts));
   if (detail.ok && Array.isArray(detail.data?.data)) {
-    const catalog = { models: [], modelCapabilities: {}, modelStates: {}, deployments: {} };
+    const catalog = {
+      models: [],
+      modelCapabilities: {},
+      modelStates: {},
+      deployments: {},
+      authFailed: false
+    };
+    const capabilityRows = {};
     for (const row of detail.data.data) {
       if (typeof row?.model_name !== "string" || row.model_name.length === 0) continue;
       const alias = row.model_name;
-      if (catalog.deployments[alias] !== void 0) continue;
-      catalog.models.push(alias);
+      if (catalog.deployments[alias] === void 0) {
+        catalog.models.push(alias);
+        catalog.deployments[alias] = [];
+        capabilityRows[alias] = [];
+      }
       const caps = row.model_info ? capabilitiesFromLiteLLMModelInfo(row.model_info) : {};
-      if (Object.keys(caps).length > 0) catalog.modelCapabilities[alias] = caps;
+      capabilityRows[alias]?.push(caps);
       const upstream = row.litellm_params?.model;
       const apiBase = row.litellm_params?.api_base;
-      catalog.deployments[alias] = {
+      catalog.deployments[alias]?.push({
         model: typeof upstream === "string" ? upstream : alias,
         ...typeof apiBase === "string" ? { apiBase } : {}
-      };
+      });
+    }
+    for (const alias of catalog.models) {
+      const caps = aggregateLiteLLMCapabilities(capabilityRows[alias] ?? []);
+      if (Object.keys(caps).length > 0) catalog.modelCapabilities[alias] = caps;
     }
     if (catalog.models.length > 0) return catalog;
   }
+  const detailAuthFailed = isAuthError(detail);
   const listOpts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs, headers };
   const list = await (ctx.signal ? probeJson({ ...listOpts, signal: ctx.signal }) : probeJson(listOpts));
-  if (!list.ok || !Array.isArray(list.data?.data)) return EMPTY_CATALOG;
+  if (!list.ok || !Array.isArray(list.data?.data)) {
+    return { ...EMPTY_CATALOG, authFailed: detailAuthFailed || isAuthError(list) };
+  }
   const models = list.data.data.map((row) => typeof row?.id === "string" ? row.id : null).filter((id) => id !== null && id.length > 0);
-  return { models, modelCapabilities: {}, modelStates: {}, deployments: {} };
+  return { models, modelCapabilities: {}, modelStates: {}, deployments: {}, authFailed: false };
 }
 var litellmRuntime = {
   id: "litellm",
@@ -3078,8 +3476,9 @@ var litellmRuntime = {
     if (catalog.models.length === 0) {
       const result2 = {
         ok: false,
-        error: "gateway is live but served no model catalog; check the target's API key"
+        error: catalog.authFailed ? "gateway rejected the key" : "gateway is live but served no model catalog; check the target's API key"
       };
+      if (catalog.authFailed) result2.authFailed = true;
       if (live.latencyMs !== void 0) result2.latencyMs = live.latencyMs;
       return result2;
     }
@@ -3099,7 +3498,18 @@ var litellmRuntime = {
     if (configured && !catalog.models.includes(configured)) {
       notes.push(`configured model '${configured}' is not in the gateway catalog`);
     }
-    const routed = Object.entries(catalog.deployments).map(([alias, deployment]) => `${alias}=${deployment.model}`).sort();
+    const routeEntries = Object.entries(catalog.deployments);
+    const physical = routeEntries.filter(([alias, deployments]) => {
+      const slash = alias.indexOf("/");
+      if (slash <= 0 || deployments.length !== 1) return false;
+      const upstream = deployments[0]?.model.replace(/^openai\//u, "");
+      return upstream === alias.slice(slash + 1);
+    });
+    if (physical.length > 0) notes.push(`physical routes: ${physical.length} node/model names map one-to-one`);
+    const routed = routeEntries.filter(([alias]) => !physical.some(([physicalAlias]) => physicalAlias === alias)).map(([alias, deployments]) => {
+      const models = [...new Set(deployments.map((deployment) => deployment.model))];
+      return `${alias}=${models.join("|")}`;
+    }).sort();
     if (routed.length > 0) notes.push(`routes: ${routed.join(", ")}`);
     if (notes.length > 0) result.notes = notes;
     return result;
@@ -3167,9 +3577,14 @@ function registerBuiltinRuntimes(registry) {
 }
 
 export {
+  isHarmonyModelId,
+  inferLocalModelFamily,
   CLIO_MIN_CONTEXT_WINDOW,
   CLIO_MIN_MAX_OUTPUT_TOKENS,
   CLIO_CONTEXT_WINDOW_WARN_BELOW,
+  EMPTY_CAPABILITIES,
+  VALID_THINKING_LEVELS,
+  availableThinkingLevels,
   extractLocalModelQuirks,
   lmStudioRootUrl,
   requestLmStudioJson,
@@ -3177,8 +3592,9 @@ export {
   lmStudioReasoningEffort,
   listLmStudioModels,
   greetLmStudio,
+  boundedExternalDiagnostic,
   formatContextWindowSlots,
   BUILTIN_RUNTIMES,
   registerBuiltinRuntimes
 };
-//# sourceMappingURL=chunk-QKIFBZKT.js.map
+//# sourceMappingURL=chunk-VW6DOEDG.js.map