@iowarp/clio-coder 0.3.7 → 0.3.8

package/dist/chunk-NMPKI6XL.js

@@ -0,0 +1,3006 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  THINKING_LEVELS
+} from "./chunk-4DGYLA73.js";
+import {
+  listCatalogModelsForRuntime,
+  mergeCapabilities,
+  synthesizeCatalogBackedModel
+} from "./chunk-PT7HYKEM.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/runtimes/builtins.ts
+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.";
+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)"
+];
+var antigravityCapabilities = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 1e6,
+  maxTokens: 8192
+};
+var antigravityCodeRuntime = {
+  id: "antigravity-code",
+  displayName: "Antigravity CLI",
+  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",
+  auth: "none",
+  authNotice: ANTIGRAVITY_AUTH_NOTICE,
+  knownModels: [...ANTIGRAVITY_MODELS],
+  binaryName: "agy",
+  headlessCommand: "agy --print",
+  outputParser: "antigravity-print-text",
+  defaultCapabilities: antigravityCapabilities,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: antigravityCapabilities,
+      runtimeId: "antigravity-code",
+      api: "google-generative-ai",
+      provider: "google",
+      defaultBaseUrl: "antigravity://local"
+    });
+  }
+};
+var antigravity_code_default = antigravityCodeRuntime;
+
+// src/domains/providers/runtimes/claude/claude-code.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/claude/common.ts
+init_esm_shims();
+var CLAUDE_CODE_AUTH_NOTICE = "Uses your existing Claude Code login from the installed `claude` command. Clio stores no Claude Code credentials.";
+var CLAUDE_CODE_MODELS = [
+  "sonnet",
+  "opus",
+  "haiku",
+  "claude-sonnet-4-5",
+  "claude-opus-4-5",
+  "claude-haiku-4-5",
+  "claude-3-7-sonnet-latest"
+];
+var claudeCodeCapabilities = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: true,
+  thinkingFormat: "anthropic-extended",
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 2e5,
+  maxTokens: 8192
+};
+function synthesizeClaudeDelegatedModel(input) {
+  return synthesizeCatalogBackedModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    runtimeId: input.runtimeId,
+    api: input.apiFamily,
+    provider: "anthropic",
+    defaultBaseUrl: "claude-code://local"
+  });
+}
+
+// src/domains/providers/runtimes/claude/claude-code.ts
+var claudeCodeRuntime = {
+  id: "claude-code",
+  displayName: "Claude Code CLI",
+  kind: "subprocess",
+  tier: "subscription",
+  apiFamily: "claude-code-subprocess",
+  auth: "claude-cli",
+  authNotice: CLAUDE_CODE_AUTH_NOTICE,
+  knownModels: [...CLAUDE_CODE_MODELS],
+  binaryName: "claude",
+  headlessCommand: "claude -p --output-format stream-json",
+  outputParser: "claude-code-stream-json",
+  defaultCapabilities: claudeCodeCapabilities,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeClaudeDelegatedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: claudeCodeCapabilities,
+      runtimeId: "claude-code",
+      apiFamily: "claude-code-subprocess"
+    });
+  }
+};
+var claude_code_default = claudeCodeRuntime;
+
+// src/domains/providers/runtimes/claude/claude-sdk.ts
+init_esm_shims();
+var claudeSdkRuntime = {
+  id: "claude-sdk",
+  displayName: "Claude Agent SDK",
+  kind: "sdk",
+  tier: "subscription",
+  apiFamily: "claude-agent-sdk",
+  auth: "claude-cli",
+  authNotice: CLAUDE_CODE_AUTH_NOTICE,
+  knownModels: [...CLAUDE_CODE_MODELS],
+  binaryName: "claude",
+  headlessCommand: "@anthropic-ai/claude-agent-sdk query()",
+  outputParser: "claude-agent-sdk-messages",
+  defaultCapabilities: claudeCodeCapabilities,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeClaudeDelegatedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: claudeCodeCapabilities,
+      runtimeId: "claude-sdk",
+      apiFamily: "claude-agent-sdk"
+    });
+  }
+};
+var claude_sdk_default = claudeSdkRuntime;
+
+// src/domains/providers/runtimes/cloud/alcf.ts
+init_esm_shims();
+
+// src/domains/providers/probe/http.ts
+init_esm_shims();
+import { performance } from "node:perf_hooks";
+async function probeHttp(opts) {
+  const { response, latencyMs, error } = await runFetch(opts);
+  if (response === null) return { ok: false, error: error ?? "unknown transport error", latencyMs };
+  const method = opts.method ?? "GET";
+  if (response.ok) return { ok: true, latencyMs };
+  if (method === "HEAD" && response.status === 405) return { ok: true, latencyMs };
+  return {
+    ok: false,
+    latencyMs,
+    error: `HTTP ${response.status}: ${response.statusText}`
+  };
+}
+async function probeJson(opts) {
+  const { response, latencyMs, error } = await runFetch(opts);
+  if (response === null) return { ok: false, error: error ?? "unknown transport error", latencyMs };
+  const method = opts.method ?? "GET";
+  if (!response.ok && !(method === "HEAD" && response.status === 405)) {
+    return {
+      ok: false,
+      latencyMs,
+      error: `HTTP ${response.status}: ${response.statusText}`
+    };
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    return { ok: false, latencyMs, error: `JSON parse: ${describeError(err)}` };
+  }
+  return { ok: true, latencyMs, data };
+}
+async function runFetch(opts) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, opts.timeoutMs);
+  const onExternalAbort = () => controller.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) controller.abort();
+    else opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const init = {
+    method: opts.method ?? "GET",
+    signal: controller.signal
+  };
+  if (opts.headers) init.headers = opts.headers;
+  if (opts.body !== void 0) init.body = opts.body;
+  const started = performance.now();
+  try {
+    const response = await fetch(opts.url, init);
+    return { response, latencyMs: Math.round(performance.now() - started) };
+  } catch (err) {
+    const latencyMs = Math.round(performance.now() - started);
+    if (timedOut) {
+      return { response: null, latencyMs, error: `timeout after ${opts.timeoutMs}ms` };
+    }
+    if (opts.signal?.aborted) {
+      return { response: null, latencyMs, error: "aborted by caller" };
+    }
+    return { response: null, latencyMs, error: describeError(err) };
+  } finally {
+    clearTimeout(timer);
+    if (opts.signal) opts.signal.removeEventListener("abort", onExternalAbort);
+  }
+}
+function describeError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const cause = err.cause;
+  if (cause instanceof Error && cause.message.length > 0) {
+    const code = cause.code;
+    return typeof code === "string" && !cause.message.includes(code) ? `${cause.message} (${code})` : cause.message;
+  }
+  return err.message;
+}
+
+// src/domains/providers/runtimes/common/local-synth.ts
+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"];
+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;
+}
+function asInteger(value) {
+  const n = asPositive(value);
+  return n !== void 0 && Number.isInteger(n) ? n : void 0;
+}
+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 = {};
+  const temperature = asPositive(raw.temperature);
+  if (temperature !== void 0) out.temperature = temperature;
+  const topP = asPositive(raw.topP);
+  if (topP !== void 0) out.topP = topP;
+  const topK = asInteger(raw.topK);
+  if (topK !== void 0) out.topK = topK;
+  const minP = asPositive(raw.minP);
+  if (minP !== void 0) out.minP = minP;
+  const rp = asPenalty(raw.repeatPenalty) ?? asPenalty(raw.repetitionPenalty);
+  if (rp !== void 0) out.repeatPenalty = rp;
+  const pp = asPenalty(raw.presencePenalty);
+  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) {
+  if (!isRecord(raw)) return void 0;
+  const out = {};
+  const thinking = extractSamplingProfile(raw.thinking);
+  if (thinking) out.thinking = thinking;
+  const instruct = extractSamplingProfile(raw.instruct);
+  if (instruct) out.instruct = instruct;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+var THINKING_MECHANISMS = [
+  "effort-levels",
+  "budget-tokens",
+  "on-off",
+  "always-on",
+  "none"
+];
+function asThinkingMechanism(value) {
+  if (typeof value !== "string") return void 0;
+  return THINKING_MECHANISMS.includes(value) ? value : void 0;
+}
+function extractBudgetByLevel(raw) {
+  if (!isRecord(raw)) return void 0;
+  const out = {};
+  const minimal = asInteger(raw.minimal);
+  if (minimal !== void 0) out.minimal = minimal;
+  const low = asInteger(raw.low);
+  if (low !== void 0) out.low = low;
+  const medium = asInteger(raw.medium);
+  if (medium !== void 0) out.medium = medium;
+  const high = asInteger(raw.high);
+  if (high !== void 0) out.high = high;
+  const xhigh = asInteger(raw.xhigh);
+  if (xhigh !== void 0) out.xhigh = xhigh;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function extractEffortByLevel(raw) {
+  if (!isRecord(raw)) return void 0;
+  const out = {};
+  if (typeof raw.off === "string" && raw.off.length > 0) out.off = raw.off;
+  if (typeof raw.minimal === "string" && raw.minimal.length > 0) out.minimal = raw.minimal;
+  if (typeof raw.low === "string" && raw.low.length > 0) out.low = raw.low;
+  if (typeof raw.medium === "string" && raw.medium.length > 0) out.medium = raw.medium;
+  if (typeof raw.high === "string" && raw.high.length > 0) out.high = raw.high;
+  if (typeof raw.xhigh === "string" && raw.xhigh.length > 0) out.xhigh = raw.xhigh;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function extractThinkingQuirks(raw) {
+  if (!isRecord(raw)) return void 0;
+  const mechanism = asThinkingMechanism(raw.mechanism);
+  if (!mechanism) return void 0;
+  const out = { mechanism };
+  const budgetByLevel = extractBudgetByLevel(raw.budgetByLevel);
+  if (budgetByLevel) out.budgetByLevel = budgetByLevel;
+  const effortByLevel = extractEffortByLevel(raw.effortByLevel);
+  if (effortByLevel) out.effortByLevel = effortByLevel;
+  if (typeof raw.guidance === "string" && raw.guidance.length > 0) out.guidance = raw.guidance;
+  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;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+// src/domains/providers/runtimes/common/local-synth.ts
+function openAIThinkingFormat(caps) {
+  switch (caps.thinkingFormat) {
+    case "qwen-chat-template":
+    case "openrouter":
+    case "zai":
+      return caps.thinkingFormat;
+    case "deepseek-r1":
+      return "deepseek";
+    case "harmony":
+      return "harmony";
+    default:
+      return void 0;
+  }
+}
+function localOpenAICompat(caps, runtimeId) {
+  const compat = {
+    supportsStore: false,
+    supportsDeveloperRole: false,
+    supportsReasoningEffort: false,
+    supportsUsageInStreaming: true,
+    supportsFinishReason: false,
+    maxTokensField: "max_tokens",
+    supportsThinkingTokenBudget: runtimeId === "vllm",
+    supportsStrictMode: false
+  };
+  const thinkingFormat = openAIThinkingFormat(caps);
+  if (thinkingFormat) compat.thinkingFormat = thinkingFormat;
+  return compat;
+}
+function localAnthropicCompat() {
+  return {
+    supportsEagerToolInputStreaming: false,
+    supportsLongCacheRetention: false
+  };
+}
+function synthLocalModel(input) {
+  const { target, wireModelId, kb, defaultCapabilities: defaultCapabilities25, apiFamily, provider } = input;
+  const caps = mergeCapabilities(defaultCapabilities25, kb?.entry.capabilities ?? null, null, target.capabilities ?? null);
+  const rawUrl = target.url ?? "";
+  const baseUrl = rawUrl.length > 0 ? input.baseUrlForTarget(rawUrl) : "";
+  const pricing = target.pricing;
+  const headers = target.auth?.headers;
+  const quirks = extractLocalModelQuirks(kb?.entry.quirks);
+  const model = {
+    id: wireModelId,
+    name: `${wireModelId} (${target.id})`,
+    api: apiFamily,
+    provider,
+    baseUrl,
+    reasoning: caps.reasoning,
+    input: caps.vision ? ["text", "image"] : ["text"],
+    cost: {
+      input: pricing?.input ?? 0,
+      output: pricing?.output ?? 0,
+      cacheRead: pricing?.cacheRead ?? 0,
+      cacheWrite: pricing?.cacheWrite ?? 0
+    },
+    contextWindow: caps.contextWindow,
+    maxTokens: caps.maxTokens,
+    clio: {
+      targetId: target.id,
+      runtimeId: target.runtime,
+      ...target.lifecycle ? { lifecycle: target.lifecycle } : {},
+      ...target.gateway === true ? { gateway: true } : {},
+      ...kb?.entry.family ? { family: kb.entry.family } : {},
+      ...quirks ? { quirks } : {},
+      ...target.lmstudio ? { lmstudio: target.lmstudio } : {}
+    }
+  };
+  if (headers) model.headers = headers;
+  if (apiFamily === "openai-completions") {
+    model.compat = localOpenAICompat(caps, target.runtime);
+  }
+  if (apiFamily === "anthropic-messages") {
+    model.compat = localAnthropicCompat();
+  }
+  return model;
+}
+function stripTrailingSlash(url2) {
+  return url2.endsWith("/") ? url2.slice(0, -1) : url2;
+}
+function stripRedundantV1(url2) {
+  return url2.endsWith("/v1") ? url2.slice(0, -"/v1".length) : url2;
+}
+var withV1 = (url2) => `${stripRedundantV1(stripTrailingSlash(url2))}/v1`;
+var withAsIs = (url2) => stripTrailingSlash(url2);
+function targetBaseUrl(target) {
+  return target.url ? stripTrailingSlash(target.url) : null;
+}
+function targetRootUrl(target) {
+  return target.url ? stripRedundantV1(stripTrailingSlash(target.url)) : null;
+}
+
+// src/domains/providers/runtimes/protocol/openai-compat.ts
+init_esm_shims();
+
+// src/core/context-floor.ts
+init_esm_shims();
+var CLIO_MIN_CONTEXT_WINDOW = 131072;
+var CLIO_MIN_MAX_OUTPUT_TOKENS = 32768;
+var CLIO_CONTEXT_WINDOW_WARN_BELOW = 128e3;
+
+// src/domains/providers/probe/reasoning.ts
+init_esm_shims();
+import { performance as performance2 } from "node:perf_hooks";
+var PROMPT = "What is 2+2? Think briefly, then answer.";
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function detectReasoningField(data) {
+  const message = data.choices?.[0]?.message;
+  if (!message) return null;
+  if (nonEmptyString(message.reasoning_content)) return "reasoning_content";
+  if (nonEmptyString(message.reasoning)) return "reasoning";
+  if (nonEmptyString(message.reasoning_text)) return "reasoning_text";
+  return null;
+}
+function trimTrailingSlash(url2) {
+  return url2.endsWith("/") ? url2.slice(0, -1) : url2;
+}
+async function probeOpenAICompatReasoning(opts) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, opts.timeoutMs);
+  const onExternalAbort = () => controller.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) controller.abort();
+    else opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const headers = { "content-type": "application/json" };
+  if (opts.apiKey && opts.apiKey.length > 0) headers.authorization = `Bearer ${opts.apiKey}`;
+  const body = JSON.stringify({
+    model: opts.modelId,
+    messages: [{ role: "user", content: PROMPT }],
+    max_tokens: 200,
+    temperature: 0,
+    stream: false,
+    reasoning_effort: "low"
+  });
+  const url2 = `${trimTrailingSlash(opts.baseUrl)}/v1/chat/completions`;
+  const started = performance2.now();
+  try {
+    const response = await fetch(url2, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const latencyMs = Math.round(performance2.now() - started);
+    if (!response.ok) {
+      return { reasoning: false, latencyMs, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    const field = detectReasoningField(data);
+    if (field) return { reasoning: true, field, latencyMs };
+    return { reasoning: false, latencyMs };
+  } catch (err) {
+    const latencyMs = Math.round(performance2.now() - started);
+    if (timedOut) return { reasoning: false, latencyMs, error: `timeout after ${opts.timeoutMs}ms` };
+    if (opts.signal?.aborted) return { reasoning: false, latencyMs, error: "aborted by caller" };
+    return { reasoning: false, latencyMs, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timer);
+    if (opts.signal) opts.signal.removeEventListener("abort", onExternalAbort);
+  }
+}
+
+// src/domains/providers/runtimes/common/probe-helpers.ts
+init_esm_shims();
+
+// src/domains/providers/types/context-window-slots.ts
+init_esm_shims();
+function formatContextWindowSlots(contextWindow, slots) {
+  const format = (n) => Math.round(n).toLocaleString("en-US");
+  return `${format(contextWindow)} (${format(slots.totalContextSize)} / ${slots.slots} slots)`;
+}
+
+// src/domains/providers/runtimes/common/probe-helpers.ts
+async function probeUrl(url2, ctx, method = "GET") {
+  const base = { url: url2, timeoutMs: ctx.httpTimeoutMs, method };
+  return ctx.signal ? probeHttp({ ...base, signal: ctx.signal }) : probeHttp(base);
+}
+async function probeOpenAIModels(base, ctx, modelsPath = "/v1/models") {
+  return (await probeOpenAIModelCatalog(base, ctx, modelsPath)).models;
+}
+var OPENAI_COMPAT_DETAIL_PATHS = ["/api/v0/models"];
+async function probeModelDetailRows(base, ctx, modelsPath) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const detailPath of OPENAI_COMPAT_DETAIL_PATHS) {
+    if (detailPath === modelsPath) continue;
+    const opts = { url: `${base}${detailPath}`, timeoutMs: ctx.httpTimeoutMs };
+    const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+    if (!result.ok || !Array.isArray(result.data?.data)) continue;
+    for (const row of result.data.data) {
+      if (typeof row?.id !== "string" || row.id.length === 0) continue;
+      if (!rows.has(row.id)) rows.set(row.id, row);
+    }
+    if (rows.size > 0) break;
+  }
+  return rows;
+}
+async function probeOpenAIModelCatalog(base, ctx, modelsPath = "/v1/models") {
+  const opts = { url: `${base}${modelsPath}`, timeoutMs: ctx.httpTimeoutMs };
+  const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+  if (!result.ok || !result.data?.data) return { models: [], modelCapabilities: {}, modelStates: {} };
+  const detail = await probeModelDetailRows(base, ctx, modelsPath);
+  const models = [];
+  const modelCapabilities = {};
+  const modelStates = {};
+  for (const row of result.data.data) {
+    if (typeof row?.id !== "string" || row.id.length === 0) continue;
+    models.push(row.id);
+    const detailRow = detail.get(row.id);
+    const caps = {
+      ...detailRow ? capabilitiesFromOpenAIModelEntry(detailRow) : {},
+      ...capabilitiesFromOpenAIModelEntry(row)
+    };
+    if (Object.keys(caps).length > 0) modelCapabilities[row.id] = caps;
+    const loadedContext = loadedContextFromEntry(row) ?? (detailRow ? loadedContextFromEntry(detailRow) : void 0);
+    const state = modelStateFromOpenAIModelEntry(row) ?? (detailRow ? modelStateFromOpenAIModelEntry(detailRow) : void 0) ?? // A reported loaded context is itself the residency answer: nothing
+    // serves a window for a model it has not loaded.
+    (loadedContext !== void 0 ? { state: "loaded" } : void 0);
+    const contextSlots = contextSlotsFromEntry(row) ?? (detailRow ? contextSlotsFromEntry(detailRow) : void 0);
+    const withSlots = contextSlots ? { ...state ?? { state: "unknown" }, contextSlots } : state;
+    if (withSlots) {
+      modelStates[row.id] = loadedContext === void 0 ? withSlots : { ...withSlots, contextLength: loadedContext };
+    }
+  }
+  return { models, modelCapabilities, modelStates };
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function firstPositiveNumber(record, keys) {
+  for (const key of keys) {
+    const value = positiveNumber(record[key]);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function capabilityListFlag(record, name) {
+  const list = record.capabilities;
+  if (!Array.isArray(list)) return void 0;
+  return list.some((entry) => entry === name) ? true : void 0;
+}
+function booleanFromAny(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function nestedRecord(record, key) {
+  const value = record[key];
+  return isRecord2(value) ? value : null;
+}
+function firstString(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function firstBoolean(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function normalizeModelState(raw) {
+  const value = raw?.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (!value) return void 0;
+  if (value === "loaded" || value === "ready" || value === "running" || value === "active") return "loaded";
+  if (value === "loading" || value === "pending" || value === "queued" || value === "starting") return "loading";
+  if (value === "unloaded" || value === "not-loaded" || value === "idle" || value === "sleeping" || value === "stopped") {
+    return "unloaded";
+  }
+  if (value === "failed" || value === "error" || value === "errored") return "failed";
+  if (value === "unknown") return "unknown";
+  return void 0;
+}
+function modelStateFromOpenAIModelEntry(row) {
+  const status = nestedRecord(row, "status");
+  const failed = firstBoolean(status, ["failed"]) ?? firstBoolean(row, ["failed"]);
+  if (failed === true) {
+    const detail = firstString(status, ["error", "reason", "message"]) ?? firstString(row, ["error", "reason", "message"]);
+    return detail ? { state: "failed", detail } : { state: "failed" };
+  }
+  const raw = typeof row.status === "string" ? row.status : firstString(status, ["value", "state", "status"]) ?? firstString(row, ["state"]);
+  const normalized = normalizeModelState(raw);
+  if (normalized) {
+    const detail = firstString(status, ["detail", "message", "reason"]);
+    return detail ? { state: normalized, detail } : { state: normalized };
+  }
+  const loaded = firstBoolean(status, ["loaded"]) ?? firstBoolean(row, ["loaded"]);
+  if (loaded === true) return { state: "loaded" };
+  if (loaded === false) return { state: "unloaded" };
+  return void 0;
+}
+function loadedContextFromEntry(row) {
+  const reported = firstPositiveNumber(row, ["loaded_context_length", "loadedContextLength"]);
+  return reported === void 0 ? void 0 : Math.floor(reported);
+}
+function statusArgsFromEntry(row) {
+  const status = nestedRecord(row, "status");
+  return argsFromStatus(status);
+}
+function contextSlotsFromEntry(row) {
+  return llamaCppRequestContextWindow(parseLlamaCppServerFlags(statusArgsFromEntry(row)))?.slots;
+}
+function capabilitiesFromOpenAIModelEntry(row) {
+  const caps = {};
+  const meta = nestedRecord(row, "meta");
+  const flags = parseLlamaCppServerFlags(statusArgsFromEntry(row));
+  const contextWindow = llamaCppRequestContextWindow(flags)?.contextWindow ?? firstPositiveNumber(row, [
+    // What is actually loaded outranks what the model could support: a
+    // model served at 8k out of a possible 262k has an 8k window today,
+    // and the run has to be planned against the real one.
+    "loaded_context_length",
+    "loadedContextLength",
+    "context_window",
+    "contextWindow",
+    "context_length",
+    "contextLength",
+    "max_context_length",
+    "maxContextLength",
+    "n_ctx"
+  ]) ?? (meta ? firstPositiveNumber(meta, ["n_ctx", "n_ctx_train", "context_length", "contextWindow"]) : void 0);
+  if (contextWindow !== void 0) caps.contextWindow = Math.floor(contextWindow);
+  const maxTokens = positiveNumber(flags.maxTokens) ?? firstPositiveNumber(row, [
+    "max_output_tokens",
+    "maxOutputTokens",
+    "max_completion_tokens",
+    "maxCompletionTokens",
+    "max_tokens",
+    "maxTokens",
+    "n_predict"
+  ]);
+  if (maxTokens !== void 0) caps.maxTokens = Math.floor(maxTokens);
+  const tools = flags.jinja ?? booleanFromAny(row, ["tools", "tool_use", "toolUse", "trained_for_tool_use"]) ?? capabilityListFlag(row, "tool_use");
+  if (tools !== void 0) caps.tools = tools;
+  const reasoning = flags.reasoning ?? (flags.reasoningBudget !== void 0 ? true : void 0) ?? booleanFromAny(row, ["reasoning", "thinking"]);
+  if (reasoning !== void 0) caps.reasoning = reasoning;
+  const architecture = nestedRecord(row, "architecture");
+  const architectureInput = architecture?.input_modalities;
+  const modalities = Array.isArray(row.modalities) ? row.modalities : Array.isArray(row.input) ? row.input : Array.isArray(architectureInput) ? architectureInput : null;
+  if (modalities) {
+    caps.vision = modalities.some((entry) => entry === "image" || entry === "vision");
+    if (modalities.some((entry) => entry === "audio")) caps.audio = true;
+  }
+  return caps;
+}
+function modelEntries(payload) {
+  if (!Array.isArray(payload?.data)) return [];
+  const out = [];
+  for (const row of payload.data) {
+    if (typeof row?.id !== "string" || row.id.length === 0) continue;
+    out.push({ id: row.id, status: row.status });
+  }
+  return out;
+}
+async function probeOpenAIModelEntries(base, ctx) {
+  const opts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs };
+  const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+  if (!result.ok) return [];
+  return modelEntries(result.data);
+}
+function llamaCppRequestContextWindow(flags) {
+  const total = positiveNumber(flags.contextSize);
+  if (total === void 0) return void 0;
+  const parallel = positiveNumber(flags.parallel);
+  if (parallel === void 0 || parallel <= 1 || flags.kvUnified === true) return { contextWindow: Math.floor(total) };
+  const slots = Math.floor(parallel);
+  return {
+    contextWindow: Math.floor(total / slots),
+    slots: { totalContextSize: Math.floor(total), slots }
+  };
+}
+function argsFromStatus(status) {
+  if (!isRecord2(status)) return [];
+  const args = status.args;
+  if (Array.isArray(args)) return args.filter((entry) => typeof entry === "string");
+  if (typeof args === "string") return args.trim().split(/\s+/).filter(Boolean);
+  return [];
+}
+function looksLikeFlag(token) {
+  return token.startsWith("-") && Number.isNaN(Number(token));
+}
+function valueAfter(args, ...flags) {
+  for (const flag of flags) {
+    const index = args.indexOf(flag);
+    if (index < 0) continue;
+    const value = args[index + 1];
+    return value && !looksLikeFlag(value) ? value : void 0;
+  }
+  return void 0;
+}
+function numberFlag(args, ...flags) {
+  const value = valueAfter(args, ...flags);
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function booleanFlag(args, ...flags) {
+  const flag = flags.find((candidate) => args.includes(candidate));
+  if (flag === void 0) return void 0;
+  const value = valueAfter(args, flag);
+  if (value === void 0) return true;
+  const normalized = value.toLowerCase();
+  if (normalized === "true" || normalized === "on" || normalized === "1") return true;
+  if (normalized === "false" || normalized === "off" || normalized === "0") return false;
+  return void 0;
+}
+function parseLlamaCppServerFlags(args) {
+  const flags = {};
+  const ctxSize = numberFlag(args, "--ctx-size", "-c");
+  if (ctxSize !== void 0) flags.contextSize = ctxSize;
+  const maxTokens = numberFlag(args, "--n-predict");
+  if (maxTokens !== void 0) flags.maxTokens = maxTokens;
+  const flashAttention = booleanFlag(args, "--flash-attn");
+  if (flashAttention !== void 0) flags.flashAttention = flashAttention;
+  const jinja = booleanFlag(args, "--jinja");
+  if (jinja !== void 0) flags.jinja = jinja;
+  const reasoningRaw = valueAfter(args, "--reasoning");
+  if (reasoningRaw) flags.reasoning = reasoningRaw === "on" || reasoningRaw === "true" || reasoningRaw === "1";
+  const reasoningBudget = numberFlag(args, "--reasoning-budget");
+  if (reasoningBudget !== void 0) flags.reasoningBudget = reasoningBudget;
+  const temperature = numberFlag(args, "--temperature");
+  if (temperature !== void 0) flags.temperature = temperature;
+  const topP = numberFlag(args, "--top-p");
+  if (topP !== void 0) flags.topP = topP;
+  const topK = numberFlag(args, "--top-k");
+  if (topK !== void 0) flags.topK = topK;
+  const nGpuLayers = numberFlag(args, "--n-gpu-layers");
+  if (nGpuLayers !== void 0) flags.nGpuLayers = nGpuLayers;
+  const parallel = numberFlag(args, "--parallel", "-np");
+  if (parallel !== void 0) flags.parallel = parallel;
+  const kvUnifiedAt = Math.max(args.lastIndexOf("--kv-unified"), args.lastIndexOf("-kvu"));
+  const noKvUnifiedAt = args.lastIndexOf("--no-kv-unified");
+  if (noKvUnifiedAt > kvUnifiedAt) flags.kvUnified = false;
+  else if (kvUnifiedAt >= 0) flags.kvUnified = booleanFlag(args, "--kv-unified", "-kvu") ?? true;
+  const cacheTypeK = valueAfter(args, "--cache-type-k");
+  if (cacheTypeK) flags.cacheTypeK = cacheTypeK;
+  const cacheTypeV = valueAfter(args, "--cache-type-v");
+  if (cacheTypeV) flags.cacheTypeV = cacheTypeV;
+  const mmproj = valueAfter(args, "--mmproj");
+  if (mmproj) flags.mmproj = mmproj;
+  const chatTemplateKwargs = valueAfter(args, "--chat-template-kwargs");
+  if (chatTemplateKwargs) flags.chatTemplateKwargs = chatTemplateKwargs;
+  return flags;
+}
+function selectedModelEntry(entries, target) {
+  const expected = target.defaultModel?.trim();
+  if (expected) return entries.find((entry) => entry.id === expected) ?? null;
+  return entries[0] ?? null;
+}
+function statusNotes(id, status) {
+  if (!isRecord2(status)) return [];
+  const notes = [];
+  if (status.failed === true) notes.push(`llama.cpp router marks ${id} as failed`);
+  const state = typeof status.state === "string" ? status.state : void 0;
+  if (state === "loading") notes.push(`llama.cpp router reports ${id} is still loading`);
+  return notes;
+}
+async function probeLlamaCppModelStatus(base, target, ctx) {
+  const entries = await probeOpenAIModelEntries(base, ctx);
+  const selected = selectedModelEntry(entries, target);
+  if (!selected) return {};
+  const args = argsFromStatus(selected.status);
+  if (args.length === 0) return { notes: statusNotes(selected.id, selected.status) };
+  const flags = parseLlamaCppServerFlags(args);
+  const caps = {};
+  const window = llamaCppRequestContextWindow(flags);
+  if (window !== void 0) caps.contextWindow = window.contextWindow;
+  if (flags.maxTokens !== void 0 && flags.maxTokens > 0) caps.maxTokens = flags.maxTokens;
+  if (flags.reasoning === true || flags.reasoningBudget !== void 0) caps.reasoning = true;
+  if (flags.mmproj) caps.vision = true;
+  if (flags.jinja === true) caps.tools = true;
+  const enrichment = { modelId: selected.id, serverFlags: flags };
+  if (Object.keys(caps).length > 0) enrichment.discoveredCapabilities = caps;
+  const notes = statusNotes(selected.id, selected.status);
+  if (window?.slots) {
+    notes.push(
+      `${selected.id} context window ${formatContextWindowSlots(window.contextWindow, window.slots)}: --ctx-size is split across --parallel slots without --kv-unified`
+    );
+  }
+  if (notes.length > 0) enrichment.notes = notes;
+  return enrichment;
+}
+async function detectModelMismatch(base, target, ctx) {
+  const expected = target.defaultModel?.trim();
+  if (!expected) return null;
+  const ids = await probeOpenAIModels(base, ctx);
+  if (ids.length === 0) return null;
+  if (ids.includes(expected)) return null;
+  const loaded = ids[0] ?? "(unknown)";
+  return `wire model id ${expected} does not match server's loaded model ${loaded}; llama.cpp serves a single fixed model`;
+}
+async function probeLlamaCppProps(base, ctx) {
+  const opts = { url: `${base}/props`, timeoutMs: ctx.httpTimeoutMs };
+  const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+  if (!result.ok || !result.data) return {};
+  const data = result.data;
+  const enrichment = {};
+  const caps = {};
+  const nCtx = data.default_generation_settings?.n_ctx;
+  if (typeof nCtx === "number" && nCtx > 0) caps.contextWindow = nCtx;
+  const nPredict = data.default_generation_settings?.n_predict;
+  if (typeof nPredict === "number" && nPredict > 0) caps.maxTokens = nPredict;
+  const vision = data.modalities?.vision;
+  if (typeof vision === "boolean") caps.vision = vision;
+  if (Object.keys(caps).length > 0) enrichment.discoveredCapabilities = caps;
+  if (typeof data.build_info === "string" && data.build_info.length > 0) {
+    enrichment.serverVersion = data.build_info;
+  }
+  return enrichment;
+}
+
+// src/domains/providers/runtimes/protocol/openai-compat.ts
+function synthesizeOpenAICompatModel(input) {
+  return synthLocalModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    apiFamily: input.apiFamily ?? "openai-completions",
+    provider: input.provider,
+    baseUrlForTarget: input.baseUrlForTarget ?? withV1
+  });
+}
+function makeOpenAICompatRuntime(spec) {
+  const apiFamily = spec.apiFamily ?? "openai-completions";
+  const asIs = spec.baseUrlStyle === "asIs";
+  const baseUrlForTarget = asIs ? withAsIs : withV1;
+  const healthPath = spec.healthPath ?? "/v1/models";
+  const modelsPath = spec.modelsPath ?? "/v1/models";
+  const probeBase = asIs ? targetBaseUrl : targetRootUrl;
+  return {
+    id: spec.id,
+    displayName: spec.displayName,
+    kind: "http",
+    tier: spec.tier,
+    apiFamily,
+    auth: spec.auth,
+    defaultCapabilities: spec.defaultCapabilities,
+    async probe(target, ctx) {
+      const base = probeBase(target);
+      if (!base) return { ok: false, error: "target has no url" };
+      const health = await probeUrl(`${base}${healthPath}`, ctx);
+      if (!health.ok) return health;
+      const catalog = await probeOpenAIModelCatalog(base, ctx, modelsPath);
+      const result = { ...health };
+      if (catalog.models.length > 0) result.models = catalog.models;
+      if (Object.keys(catalog.modelStates).length > 0) result.modelStates = catalog.modelStates;
+      if (Object.keys(catalog.modelCapabilities).length > 0) {
+        result.modelCapabilities = catalog.modelCapabilities;
+        const selected = target.defaultModel?.trim();
+        const selectedCaps = selected ? catalog.modelCapabilities[selected] : void 0;
+        if (selected && selectedCaps) {
+          result.discoveredCapabilities = selectedCaps;
+          result.capabilityModelId = selected;
+        }
+      }
+      return result;
+    },
+    async probeModels(target, ctx) {
+      const base = probeBase(target);
+      if (!base) return [];
+      return probeOpenAIModels(base, ctx, modelsPath);
+    },
+    async probeReasoning(target, modelId, ctx) {
+      const base = probeBase(target);
+      if (!base) return { reasoning: false, latencyMs: 0, error: "target has no url" };
+      const apiKeyEnv = target.auth?.apiKeyEnvVar;
+      const apiKey = apiKeyEnv && ctx.credentialsPresent.has(apiKeyEnv) ? process.env[apiKeyEnv] : void 0;
+      const probeOpts = {
+        baseUrl: base,
+        modelId,
+        timeoutMs: Math.max(ctx.httpTimeoutMs, 8e3)
+      };
+      if (apiKey) probeOpts.apiKey = apiKey;
+      if (ctx.signal) probeOpts.signal = ctx.signal;
+      return probeOpenAICompatReasoning(probeOpts);
+    },
+    synthesizeModel(target, wireModelId, kb) {
+      return synthesizeOpenAICompatModel({
+        target,
+        wireModelId,
+        kb,
+        defaultCapabilities: spec.defaultCapabilities,
+        apiFamily,
+        provider: spec.provider,
+        baseUrlForTarget
+      });
+    }
+  };
+}
+var defaultCapabilities = {
+  chat: true,
+  tools: false,
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var openai_compat_default = makeOpenAICompatRuntime({
+  id: "openai-compat",
+  displayName: "Generic OpenAI-compatible",
+  provider: "openai-compat",
+  auth: "api-key",
+  tier: "protocol",
+  defaultCapabilities
+});
+
+// src/domains/providers/runtimes/cloud/alcf.ts
+var CATALOG_URL = "https://inference-api.alcf.anl.gov/resource_server/list-endpoints";
+var GATEWAY_ORIGIN = "https://inference-api.alcf.anl.gov/resource_server";
+var defaultCapabilities2 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 32768,
+  maxTokens: 4096
+};
+var KNOWN_MODELS = [
+  "openai/gpt-oss-120b",
+  "openai/gpt-oss-20b",
+  "gpt-oss-120b",
+  "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+  "meta-llama/Llama-4-Scout-17B-16E-Instruct"
+];
+function clusterFromUrl(url2) {
+  if (!url2) return null;
+  const match = /\/resource_server\/([^/]+)\//.exec(url2);
+  return match ? match[1] ?? null : null;
+}
+function frameworkForCluster(cluster) {
+  return cluster === "metis" ? "api" : "vllm";
+}
+function catalogModels(payload, cluster, framework) {
+  const models = payload.clusters?.[cluster]?.frameworks?.[framework]?.models;
+  if (!Array.isArray(models)) return [];
+  return models.map((model) => String(model).trim()).filter((model) => model.length > 0);
+}
+function runningModels(payload) {
+  const out = [];
+  for (const job of payload.running ?? []) {
+    for (const raw of String(job.Models ?? "").split(",")) {
+      const id = raw.trim();
+      if (id.length > 0) out.push(id);
+    }
+  }
+  return out;
+}
+function dedupe(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of ids) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+function authHeaders(ctx) {
+  return { Authorization: `Bearer ${ctx.authToken}`, Accept: "application/json" };
+}
+async function discover(target, ctx) {
+  if (!target.url) return { ok: false, error: "ALCF target has no url" };
+  const cluster = clusterFromUrl(target.url);
+  if (!cluster) {
+    return { ok: false, error: `cannot determine ALCF cluster from url ${target.url}` };
+  }
+  if (!ctx.authToken) {
+    return { ok: false, error: "ALCF requires Globus auth; run `clio-coder auth login alcf`." };
+  }
+  const framework = frameworkForCluster(cluster);
+  const headers = authHeaders(ctx);
+  const catalog = await probeJson({
+    url: CATALOG_URL,
+    headers,
+    timeoutMs: ctx.httpTimeoutMs,
+    ...ctx.signal ? { signal: ctx.signal } : {}
+  });
+  if (!catalog.ok || !catalog.data) {
+    const reason = catalog.error ?? "unknown error";
+    const hint = reason.includes("401") ? " (token expired or rejected; run `clio-coder auth login alcf` again)" : "";
+    return {
+      ok: false,
+      error: `ALCF endpoint catalog unreachable: ${reason}${hint}`,
+      ...catalog.latencyMs !== void 0 ? { latencyMs: catalog.latencyMs } : {}
+    };
+  }
+  const fromCatalog = catalogModels(catalog.data, cluster, framework);
+  let live = [];
+  try {
+    const jobs = await probeJson({
+      url: `${GATEWAY_ORIGIN}/${cluster}/jobs`,
+      headers,
+      timeoutMs: Math.min(ctx.httpTimeoutMs, 12e3),
+      ...ctx.signal ? { signal: ctx.signal } : {}
+    });
+    if (jobs.ok && jobs.data) live = runningModels(jobs.data);
+  } catch {
+  }
+  const models = dedupe([...fromCatalog, ...live]);
+  const result = { ok: true, models };
+  if (catalog.latencyMs !== void 0) result.latencyMs = catalog.latencyMs;
+  if (models.length === 0) {
+    result.notes = [`ALCF ${cluster}/${framework} reported no models; the gateway may have no running jobs.`];
+  }
+  return result;
+}
+var alcfRuntime = {
+  id: "alcf",
+  displayName: "ALCF Inference (Globus)",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-completions",
+  auth: "oauth",
+  knownModels: KNOWN_MODELS,
+  defaultCapabilities: defaultCapabilities2,
+  probe(target, ctx) {
+    return discover(target, ctx);
+  },
+  async probeModels(target, ctx) {
+    const result = await discover(target, ctx);
+    return result.models ?? [];
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    const model = synthesizeOpenAICompatModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities2,
+      apiFamily: "openai-completions",
+      provider: "alcf",
+      baseUrlForTarget: withAsIs
+    });
+    const meta = model.clio;
+    if (meta) meta.chatTemplateKwargsUnsupported = true;
+    return model;
+  }
+};
+var alcf_default = alcfRuntime;
+
+// src/domains/providers/runtimes/cloud/anthropic.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/protocol/anthropic-messages.ts
+init_esm_shims();
+function synthesizeAnthropicMessagesModel(input) {
+  return synthesizeCatalogBackedModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    runtimeId: "anthropic",
+    api: "anthropic-messages",
+    provider: input.provider,
+    defaultBaseUrl: input.defaultBaseUrl
+  });
+}
+
+// src/domains/providers/runtimes/cloud/anthropic.ts
+var defaultCapabilities3 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: true,
+  thinkingFormat: "anthropic-extended",
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 2e5,
+  maxTokens: 8192
+};
+var anthropicRuntime = {
+  id: "anthropic",
+  displayName: "Anthropic",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "anthropic-messages",
+  auth: "api-key",
+  credentialsEnvVar: "ANTHROPIC_API_KEY",
+  defaultCapabilities: defaultCapabilities3,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeAnthropicMessagesModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities3,
+      provider: "anthropic",
+      defaultBaseUrl: "https://api.anthropic.com"
+    });
+  }
+};
+var anthropic_default = anthropicRuntime;
+
+// src/domains/providers/runtimes/cloud/anthropic-max.ts
+init_esm_shims();
+var defaultCapabilities4 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: true,
+  thinkingFormat: "anthropic-extended",
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 2e5,
+  maxTokens: 8192
+};
+var anthropicMaxRuntime = {
+  id: "anthropic-max",
+  displayName: "Anthropic (Claude Pro/Max)",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "anthropic-messages",
+  auth: "oauth",
+  oauthProviderId: "anthropic",
+  authNotice: "Connects with your Claude Pro/Max subscription via OAuth (the same path Claude Code uses). Using subscription credentials outside Anthropic's first-party apps may not align with their terms of service; enable at your own discretion.",
+  defaultCapabilities: defaultCapabilities4,
+  async probeModels(_target, _ctx) {
+    return listCatalogModelsForRuntime("anthropic-max").map((model) => model.id);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities4,
+      runtimeId: "anthropic-max",
+      api: "anthropic-messages",
+      provider: "anthropic",
+      defaultBaseUrl: "https://api.anthropic.com"
+    });
+  }
+};
+var anthropic_max_default = anthropicMaxRuntime;
+
+// src/domains/providers/runtimes/cloud/bedrock.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/protocol/bedrock.ts
+init_esm_shims();
+function synthesizeBedrockModel(input) {
+  return synthesizeCatalogBackedModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    runtimeId: "bedrock",
+    api: "bedrock-converse-stream",
+    provider: "amazon-bedrock",
+    defaultBaseUrl: ""
+  });
+}
+
+// src/domains/providers/runtimes/cloud/bedrock.ts
+var defaultCapabilities5 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: true,
+  thinkingFormat: "anthropic-extended",
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 2e5,
+  maxTokens: 8192
+};
+var bedrockRuntime = {
+  id: "bedrock",
+  displayName: "Amazon Bedrock",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "bedrock-converse-stream",
+  auth: "aws-sdk",
+  defaultCapabilities: defaultCapabilities5,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeBedrockModel({ target, wireModelId, kb, defaultCapabilities: defaultCapabilities5 });
+  }
+};
+var bedrock_default = bedrockRuntime;
+
+// src/domains/providers/runtimes/cloud/deepseek.ts
+init_esm_shims();
+var defaultCapabilities6 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  thinkingFormat: "deepseek-r1",
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 128e3,
+  maxTokens: 65536
+};
+var deepseekRuntime = {
+  id: "deepseek",
+  displayName: "DeepSeek",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  credentialsEnvVar: "DEEPSEEK_API_KEY",
+  defaultCapabilities: defaultCapabilities6,
+  async probeModels(_target, _ctx) {
+    return listCatalogModelsForRuntime("deepseek").map((model) => model.id);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities6,
+      runtimeId: "deepseek",
+      api: "openai-completions",
+      provider: "deepseek",
+      defaultBaseUrl: "https://api.deepseek.com"
+    });
+  }
+};
+var deepseek_default = deepseekRuntime;
+
+// src/domains/providers/runtimes/cloud/google.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/protocol/google.ts
+init_esm_shims();
+function synthesizeGoogleModel(input) {
+  return synthesizeCatalogBackedModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    runtimeId: "google",
+    api: "google-generative-ai",
+    provider: "google",
+    defaultBaseUrl: input.defaultBaseUrl
+  });
+}
+
+// src/domains/providers/runtimes/cloud/google.ts
+var defaultCapabilities7 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 2e6,
+  maxTokens: 8192
+};
+var googleRuntime = {
+  id: "google",
+  displayName: "Google Generative AI",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "google-generative-ai",
+  auth: "api-key",
+  credentialsEnvVar: "GOOGLE_API_KEY",
+  defaultCapabilities: defaultCapabilities7,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeGoogleModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities7,
+      defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta"
+    });
+  }
+};
+var google_default = googleRuntime;
+
+// src/domains/providers/runtimes/cloud/groq.ts
+init_esm_shims();
+var defaultCapabilities8 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 128e3,
+  maxTokens: 8192
+};
+var groqRuntime = {
+  id: "groq",
+  displayName: "Groq",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  credentialsEnvVar: "GROQ_API_KEY",
+  defaultCapabilities: defaultCapabilities8,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities8,
+      runtimeId: "groq",
+      api: "openai-completions",
+      provider: "groq",
+      defaultBaseUrl: "https://api.groq.com/openai/v1"
+    });
+  }
+};
+var groq_default = groqRuntime;
+
+// src/domains/providers/runtimes/cloud/mistral.ts
+init_esm_shims();
+var defaultCapabilities9 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "mistral",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 128e3,
+  maxTokens: 8192
+};
+var mistralRuntime = {
+  id: "mistral",
+  displayName: "Mistral AI",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "mistral-conversations",
+  auth: "api-key",
+  credentialsEnvVar: "MISTRAL_API_KEY",
+  defaultCapabilities: defaultCapabilities9,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities9,
+      runtimeId: "mistral",
+      api: "mistral-conversations",
+      provider: "mistral",
+      defaultBaseUrl: "https://api.mistral.ai"
+    });
+  }
+};
+var mistral_default = mistralRuntime;
+
+// src/domains/providers/runtimes/cloud/openai.ts
+init_esm_shims();
+var defaultCapabilities10 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 272e3,
+  maxTokens: 16384
+};
+var openaiRuntime = {
+  id: "openai",
+  displayName: "OpenAI",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-responses",
+  auth: "api-key",
+  credentialsEnvVar: "OPENAI_API_KEY",
+  defaultCapabilities: defaultCapabilities10,
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities10,
+      runtimeId: "openai",
+      api: "openai-responses",
+      provider: "openai",
+      defaultBaseUrl: "https://api.openai.com/v1"
+    });
+  }
+};
+var openai_default = openaiRuntime;
+
+// src/domains/providers/runtimes/cloud/openai-codex.ts
+init_esm_shims();
+var defaultCapabilities11 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: true,
+  thinkingFormat: "openai-codex",
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 272e3,
+  maxTokens: 16384
+};
+var openaiCodexRuntime = {
+  id: "openai-codex",
+  displayName: "OpenAI Codex",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-codex-responses",
+  auth: "oauth",
+  defaultCapabilities: defaultCapabilities11,
+  async probeModels(_target, _ctx) {
+    return listCatalogModelsForRuntime("openai-codex").map((model) => model.id);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities11,
+      runtimeId: "openai-codex",
+      api: "openai-codex-responses",
+      provider: "openai-codex",
+      defaultBaseUrl: "https://chatgpt.com/backend-api"
+    });
+  }
+};
+var openai_codex_default = openaiCodexRuntime;
+
+// src/domains/providers/runtimes/cloud/openrouter.ts
+init_esm_shims();
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var OPENROUTER_HEADERS = {
+  "HTTP-Referer": "https://github.com/iowarp/clio-coder",
+  "X-OpenRouter-Title": "Clio Coder"
+};
+var defaultCapabilities12 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  thinkingFormat: "openrouter",
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: 128e3,
+  maxTokens: 8192
+};
+function trimTrailingSlash2(value) {
+  return value.endsWith("/") && value.length > 1 ? value.slice(0, -1) : value;
+}
+function targetBaseUrl2(target) {
+  return trimTrailingSlash2(target.url ?? OPENROUTER_BASE_URL);
+}
+function modelsUrl(target) {
+  return `${targetBaseUrl2(target)}/models`;
+}
+function probeHeaders(target, ctx) {
+  const headers = { ...OPENROUTER_HEADERS, ...target.auth?.headers ?? {} };
+  const envName = target.auth?.apiKeyEnvVar ?? "OPENROUTER_API_KEY";
+  if (ctx.credentialsPresent.has(envName)) {
+    const key = process.env[envName]?.trim();
+    if (key) headers.authorization = `Bearer ${key}`;
+  }
+  return headers;
+}
+async function fetchModels(target, ctx) {
+  const opts = {
+    url: modelsUrl(target),
+    timeoutMs: ctx.httpTimeoutMs,
+    headers: probeHeaders(target, ctx)
+  };
+  const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+  if (!result.ok) return result;
+  const models = (result.data?.data ?? []).map((row) => typeof row?.id === "string" ? row.id : null).filter((id) => id !== null);
+  const out = { ok: true, models };
+  if (result.latencyMs !== void 0) out.latencyMs = result.latencyMs;
+  const configured = target.defaultModel?.trim();
+  if (configured && models.length > 0 && !models.includes(configured)) {
+    out.ok = false;
+    out.error = `configured model '${configured}' was not returned by OpenRouter`;
+  }
+  return out;
+}
+var openrouterRuntime = {
+  id: "openrouter",
+  displayName: "OpenRouter",
+  kind: "http",
+  tier: "cloud",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  credentialsEnvVar: "OPENROUTER_API_KEY",
+  defaultCapabilities: defaultCapabilities12,
+  probe(target, ctx) {
+    return fetchModels(target, ctx);
+  },
+  async probeModels(target, ctx) {
+    const result = await fetchModels(target, ctx);
+    return result.ok && result.models ? [...result.models] : [];
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthesizeCatalogBackedModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities12,
+      runtimeId: "openrouter",
+      api: "openai-completions",
+      provider: "openrouter",
+      defaultBaseUrl: OPENROUTER_BASE_URL,
+      defaultHeaders: OPENROUTER_HEADERS
+    });
+  }
+};
+var openrouter_default = openrouterRuntime;
+
+// src/domains/providers/runtimes/local-native/lemonade-anthropic.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/protocol/anthropic-compat.ts
+init_esm_shims();
+function synthesizeAnthropicCompatModel(input) {
+  return synthLocalModel({
+    target: input.target,
+    wireModelId: input.wireModelId,
+    kb: input.kb,
+    defaultCapabilities: input.defaultCapabilities,
+    apiFamily: "anthropic-messages",
+    provider: input.provider,
+    baseUrlForTarget: input.baseUrlForTarget ?? withAsIs
+  });
+}
+function makeAnthropicCompatRuntime(spec) {
+  const messagesPath = spec.messagesPath ?? "/v1/messages";
+  const modelsPath = spec.modelsPath ?? "/v1/models";
+  return {
+    id: spec.id,
+    displayName: spec.displayName,
+    kind: "http",
+    tier: spec.tier,
+    apiFamily: "anthropic-messages",
+    auth: spec.auth,
+    defaultCapabilities: spec.defaultCapabilities,
+    ...spec.hidden === true ? { hidden: true } : {},
+    async probe(target, ctx) {
+      const base = targetBaseUrl(target);
+      if (!base) return { ok: false, error: "target has no url" };
+      return probeUrl(`${base}${messagesPath}`, ctx, "HEAD");
+    },
+    async probeModels(target, ctx) {
+      const base = targetBaseUrl(target);
+      if (!base) return [];
+      return probeOpenAIModels(base, ctx, modelsPath);
+    },
+    synthesizeModel(target, wireModelId, kb) {
+      return synthesizeAnthropicCompatModel({
+        target,
+        wireModelId,
+        kb,
+        defaultCapabilities: spec.defaultCapabilities,
+        provider: spec.provider
+      });
+    }
+  };
+}
+var defaultCapabilities13 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var anthropic_compat_default = makeAnthropicCompatRuntime({
+  id: "anthropic-compat",
+  displayName: "Generic Anthropic-compatible",
+  provider: "anthropic-compat",
+  auth: "api-key",
+  tier: "protocol",
+  defaultCapabilities: defaultCapabilities13
+});
+
+// src/domains/providers/runtimes/local-native/lemonade-anthropic.ts
+var defaultCapabilities14 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var lemonade_anthropic_default = makeAnthropicCompatRuntime({
+  id: "lemonade-anthropic",
+  displayName: "Lemonade (Anthropic-compat)",
+  provider: "lemonade",
+  auth: "api-key",
+  tier: "local-native",
+  defaultCapabilities: defaultCapabilities14,
+  hidden: true
+});
+
+// src/domains/providers/runtimes/local-native/lemonade-openai.ts
+init_esm_shims();
+var defaultCapabilities15 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var lemonade_openai_default = makeOpenAICompatRuntime({
+  id: "lemonade",
+  displayName: "Lemonade (OpenAI-compat)",
+  provider: "lemonade",
+  auth: "api-key",
+  tier: "local-native",
+  defaultCapabilities: defaultCapabilities15
+});
+
+// src/domains/providers/runtimes/local-native/llamacpp.ts
+init_esm_shims();
+var defaultCapabilities16 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  structuredOutputs: "json-schema",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+function targetUrl(target) {
+  return targetRootUrl(target);
+}
+var llamacppRuntime = {
+  id: "llamacpp",
+  displayName: "llama.cpp",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities16,
+  async probe(target, ctx) {
+    const base = targetUrl(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs };
+    const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
+    if (!health.ok) return health;
+    const props = await probeLlamaCppProps(base, ctx);
+    const status = await probeLlamaCppModelStatus(base, target, ctx);
+    const catalog = await probeOpenAIModelCatalog(base, ctx);
+    const result = { ok: true };
+    if (catalog.models.length > 0) result.models = catalog.models;
+    if (Object.keys(catalog.modelCapabilities).length > 0) result.modelCapabilities = catalog.modelCapabilities;
+    if (Object.keys(catalog.modelStates).length > 0) result.modelStates = catalog.modelStates;
+    if (typeof health.latencyMs === "number") result.latencyMs = health.latencyMs;
+    const discoveredCapabilities = {
+      ...props.discoveredCapabilities ?? {},
+      ...status.discoveredCapabilities ?? {}
+    };
+    if (Object.keys(discoveredCapabilities).length > 0) {
+      result.discoveredCapabilities = discoveredCapabilities;
+      if (status.modelId) result.capabilityModelId = status.modelId;
+    }
+    if (props.serverVersion) result.serverVersion = props.serverVersion;
+    const note = await detectModelMismatch(base, target, ctx);
+    const notes = [...status.notes ?? [], ...note ? [note] : []];
+    if (notes.length > 0) result.notes = notes;
+    return result;
+  },
+  async probeModels(target, ctx) {
+    const base = targetUrl(target);
+    if (!base) return [];
+    return probeOpenAIModels(base, ctx);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities16,
+      apiFamily: "openai-completions",
+      provider: "llamacpp",
+      baseUrlForTarget: withV1
+    });
+  }
+};
+var llamacpp_default = llamacppRuntime;
+
+// src/domains/providers/runtimes/local-native/llamacpp-anthropic.ts
+init_esm_shims();
+var defaultCapabilities17 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "anthropic",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: true,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+function url(target) {
+  return target.url ? stripTrailingSlash(target.url) : null;
+}
+var llamacppAnthropicRuntime = {
+  id: "llamacpp-anthropic",
+  displayName: "llama.cpp (Anthropic-compat)",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "anthropic-messages",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities17,
+  hidden: true,
+  async probe(target, ctx) {
+    const base = url(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs };
+    const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
+    if (!health.ok) return health;
+    const headOpts = {
+      url: `${base}/v1/messages`,
+      method: "HEAD",
+      timeoutMs: ctx.httpTimeoutMs
+    };
+    const head = await (ctx.signal ? probeHttp({ ...headOpts, signal: ctx.signal }) : probeHttp(headOpts));
+    if (!head.ok) return head;
+    const props = await probeLlamaCppProps(base, ctx);
+    const enriched = { ...head };
+    if (props.discoveredCapabilities) enriched.discoveredCapabilities = props.discoveredCapabilities;
+    if (props.serverVersion) enriched.serverVersion = props.serverVersion;
+    const note = await detectModelMismatch(base, target, ctx);
+    if (note) enriched.notes = [note];
+    return enriched;
+  },
+  async probeModels(target, ctx) {
+    const base = url(target);
+    if (!base) return [];
+    const opts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs };
+    const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+    if (!result.ok || !result.data?.data) return [];
+    return result.data.data.map((row) => typeof row?.id === "string" ? row.id : null).filter((id) => id !== null);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities17,
+      apiFamily: "anthropic-messages",
+      provider: "llamacpp",
+      baseUrlForTarget: withAsIs
+    });
+  }
+};
+var llamacpp_anthropic_default = llamacppAnthropicRuntime;
+
+// src/domains/providers/runtimes/local-native/llamacpp-completion.ts
+init_esm_shims();
+var defaultCapabilities18 = {
+  chat: false,
+  tools: false,
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: true,
+  structuredOutputs: "gbnf",
+  contextWindow: 8192,
+  maxTokens: 4096
+};
+function targetUrl2(target) {
+  return targetRootUrl(target);
+}
+function parseChunk(raw) {
+  const chunk = {
+    content: typeof raw.content === "string" ? raw.content : "",
+    stop: raw.stop === true
+  };
+  if (raw.stop_type === "eos" || raw.stop_type === "limit" || raw.stop_type === "word" || raw.stop_type === "none") {
+    chunk.stop_type = raw.stop_type;
+  }
+  if (typeof raw.tokens_predicted === "number") chunk.tokens_predicted = raw.tokens_predicted;
+  if (typeof raw.tokens_evaluated === "number") chunk.tokens_evaluated = raw.tokens_evaluated;
+  return chunk;
+}
+async function* streamSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffered = "";
+  let droppedFrames = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let nl = buffered.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffered.slice(0, nl).trimEnd();
+        buffered = buffered.slice(nl + 1);
+        nl = buffered.indexOf("\n");
+        if (line.length === 0) continue;
+        const payload = line.startsWith("data:") ? line.slice(5).trim() : line;
+        if (payload.length === 0 || payload === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(payload);
+          const chunk = parseChunk(parsed);
+          yield chunk;
+          if (chunk.stop) return;
+        } catch {
+          droppedFrames += 1;
+        }
+      }
+    }
+    const tail = buffered.trim();
+    if (tail.length > 0) {
+      const payload = tail.startsWith("data:") ? tail.slice(5).trim() : tail;
+      if (payload !== "[DONE]") {
+        try {
+          const parsed = JSON.parse(payload);
+          yield parseChunk(parsed);
+        } catch {
+          droppedFrames += 1;
+        }
+      }
+    }
+  } finally {
+    if (droppedFrames > 0) {
+      process.stderr.write(`[clio:llamacpp] dropped ${droppedFrames} malformed stream frame(s)
+`);
+    }
+    reader.releaseLock();
+  }
+}
+async function postStream(url2, body, signal) {
+  const init = {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "text/event-stream" },
+    body: JSON.stringify(body)
+  };
+  if (signal) init.signal = signal;
+  const response = await fetch(url2, init);
+  if (!response.ok || !response.body) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return response.body;
+}
+function buildCompleteBody(opts) {
+  const body = { prompt: opts.prompt, stream: true };
+  if (opts.n_predict !== void 0) body.n_predict = opts.n_predict;
+  if (opts.stop && opts.stop.length > 0) body.stop = opts.stop;
+  if (opts.grammar) body.grammar = opts.grammar;
+  if (opts.json_schema) body.json_schema = opts.json_schema;
+  if (opts.cache_prompt !== void 0) body.cache_prompt = opts.cache_prompt;
+  return body;
+}
+function buildInfillBody(opts) {
+  const body = buildCompleteBody(opts);
+  body.input_prefix = opts.input_prefix;
+  body.input_suffix = opts.input_suffix;
+  if (opts.input_extra) body.input_extra = opts.input_extra;
+  return body;
+}
+var llamacppCompletionRuntime = {
+  id: "llamacpp-completion",
+  displayName: "llama.cpp (completion / infill)",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities18,
+  hidden: true,
+  async probe(target, ctx) {
+    const base = targetUrl2(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs };
+    const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
+    if (!health.ok) return health;
+    const props = await probeLlamaCppProps(base, ctx);
+    const status = await probeLlamaCppModelStatus(base, target, ctx);
+    const enriched = { ...health };
+    const discoveredCapabilities = {
+      ...props.discoveredCapabilities ?? {},
+      ...status.discoveredCapabilities ?? {}
+    };
+    if (Object.keys(discoveredCapabilities).length > 0) {
+      enriched.discoveredCapabilities = discoveredCapabilities;
+      if (status.modelId) enriched.capabilityModelId = status.modelId;
+    }
+    if (props.serverVersion) enriched.serverVersion = props.serverVersion;
+    const note = await detectModelMismatch(base, target, ctx);
+    const notes = [...status.notes ?? [], ...note ? [note] : []];
+    if (notes.length > 0) enriched.notes = notes;
+    return enriched;
+  },
+  async probeModels(target, ctx) {
+    const base = targetUrl2(target);
+    if (!base) return [];
+    return probeOpenAIModels(base, ctx);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities18,
+      apiFamily: "openai-completions",
+      provider: "llamacpp",
+      baseUrlForTarget: withV1
+    });
+  },
+  async *complete(target, opts) {
+    const base = targetUrl2(target);
+    if (!base) throw new Error("target has no url");
+    const body = await postStream(`${base}/completion`, buildCompleteBody(opts), opts.signal);
+    for await (const chunk of streamSse(body)) yield chunk;
+  },
+  async *infill(target, opts) {
+    const base = targetUrl2(target);
+    if (!base) throw new Error("target has no url");
+    const body = await postStream(`${base}/infill`, buildInfillBody(opts), opts.signal);
+    for await (const chunk of streamSse(body)) yield chunk;
+  }
+};
+var llamacpp_completion_default = llamacppCompletionRuntime;
+
+// src/domains/providers/runtimes/local-native/llamacpp-embed.ts
+init_esm_shims();
+var defaultCapabilities19 = {
+  chat: false,
+  tools: false,
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: true,
+  rerank: false,
+  fim: false,
+  contextWindow: 8192,
+  maxTokens: 0
+};
+function targetUrl3(target) {
+  return targetRootUrl(target);
+}
+function meanPool(matrix) {
+  if (matrix.length === 0) return [];
+  const dim = matrix[0]?.length ?? 0;
+  const sum = new Array(dim).fill(0);
+  for (const row of matrix) {
+    for (let i = 0; i < dim; i++) sum[i] = (sum[i] ?? 0) + (row[i] ?? 0);
+  }
+  return sum.map((v) => v / matrix.length);
+}
+function flattenNativeEmbedding(entry) {
+  const value = entry.embedding;
+  if (!value || value.length === 0) return [];
+  if (Array.isArray(value[0])) return meanPool(value);
+  return value;
+}
+async function postJson(url2, body, signal) {
+  const init = {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  };
+  if (signal) init.signal = signal;
+  const response = await fetch(url2, init);
+  if (!response.ok) return { status: response.status, data: null };
+  try {
+    const data = await response.json();
+    return { status: response.status, data };
+  } catch {
+    return { status: response.status, data: null };
+  }
+}
+var llamacppEmbedRuntime = {
+  id: "llamacpp-embed",
+  displayName: "llama.cpp (embeddings)",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities19,
+  hidden: true,
+  async probe(target, ctx) {
+    const base = targetUrl3(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs };
+    const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
+    if (!health.ok) return health;
+    const probeResponse = await fetch(`${base}/embedding`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ content: "probe" }),
+      ...ctx.signal ? { signal: ctx.signal } : {}
+    }).catch((err) => {
+      return new Response(null, { status: 599, statusText: String(err) });
+    });
+    if (!probeResponse.ok) {
+      return { ok: false, error: `/embedding not available: HTTP ${probeResponse.status}` };
+    }
+    const props = await probeLlamaCppProps(base, ctx);
+    const result = { ok: true };
+    if (health.latencyMs !== void 0) result.latencyMs = health.latencyMs;
+    if (props.discoveredCapabilities) result.discoveredCapabilities = props.discoveredCapabilities;
+    if (props.serverVersion) result.serverVersion = props.serverVersion;
+    return result;
+  },
+  async probeModels(target, ctx) {
+    const base = targetUrl3(target);
+    if (!base) return [];
+    return probeOpenAIModels(base, ctx);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities19,
+      apiFamily: "openai-completions",
+      provider: "llamacpp",
+      baseUrlForTarget: withV1
+    });
+  },
+  async embed(target, input, ctx) {
+    const base = targetUrl3(target);
+    if (!base) throw new Error("target has no url");
+    const modelId = target.defaultModel ?? "default";
+    const inputs = Array.isArray(input) ? input : [input];
+    const oai = await postJson(
+      `${base}/v1/embeddings`,
+      { input: inputs, model: modelId, encoding_format: "float" },
+      ctx.signal
+    );
+    if (oai.data && Array.isArray(oai.data.data)) {
+      const rows = oai.data.data;
+      const sorted = [...rows].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      const vectors2 = sorted.map((row) => row.embedding ?? []);
+      const tokens = oai.data.usage?.total_tokens ?? oai.data.usage?.prompt_tokens ?? void 0;
+      const dim = vectors2[0]?.length ?? 0;
+      const result = {
+        vectors: vectors2,
+        model: oai.data.model ?? modelId,
+        dimensions: dim
+      };
+      if (tokens !== void 0) result.tokensUsed = tokens;
+      return result;
+    }
+    const probeOpts = { url: `${base}/embedding`, timeoutMs: ctx.httpTimeoutMs };
+    const native = await (ctx.signal ? probeJson({
+      ...probeOpts,
+      method: "POST",
+      body: JSON.stringify({ content: inputs }),
+      headers: { "content-type": "application/json" },
+      signal: ctx.signal
+    }) : probeJson({
+      ...probeOpts,
+      method: "POST",
+      body: JSON.stringify({ content: inputs }),
+      headers: { "content-type": "application/json" }
+    }));
+    if (!native.ok || !native.data) {
+      throw new Error(`llama.cpp embedding failed: ${native.error ?? "unknown"}`);
+    }
+    const items = native.data;
+    items.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    const vectors = items.map(flattenNativeEmbedding);
+    return {
+      vectors,
+      model: modelId,
+      dimensions: vectors[0]?.length ?? 0
+    };
+  }
+};
+var llamacpp_embed_default = llamacppEmbedRuntime;
+
+// src/domains/providers/runtimes/local-native/llamacpp-rerank.ts
+init_esm_shims();
+var defaultCapabilities20 = {
+  chat: false,
+  tools: false,
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: true,
+  fim: false,
+  contextWindow: 8192,
+  maxTokens: 0
+};
+function targetUrl4(target) {
+  return targetRootUrl(target);
+}
+var llamacppRerankRuntime = {
+  id: "llamacpp-rerank",
+  displayName: "llama.cpp (rerank)",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities20,
+  hidden: true,
+  async probe(target, ctx) {
+    const base = targetUrl4(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs };
+    const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
+    if (!health.ok) return health;
+    const modelId = target.defaultModel ?? "default";
+    const probeResponse = await fetch(`${base}/reranking`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ query: "probe", documents: ["a"], model: modelId }),
+      ...ctx.signal ? { signal: ctx.signal } : {}
+    }).catch((err) => new Response(null, { status: 599, statusText: String(err) }));
+    if (!(probeResponse.status === 200 || probeResponse.status === 202)) {
+      return { ok: false, error: `/reranking not available: HTTP ${probeResponse.status}` };
+    }
+    const props = await probeLlamaCppProps(base, ctx);
+    const result = { ok: true };
+    if (health.latencyMs !== void 0) result.latencyMs = health.latencyMs;
+    if (props.discoveredCapabilities) result.discoveredCapabilities = props.discoveredCapabilities;
+    if (props.serverVersion) result.serverVersion = props.serverVersion;
+    return result;
+  },
+  async probeModels(target, ctx) {
+    const base = targetUrl4(target);
+    if (!base) return [];
+    return probeOpenAIModels(base, ctx);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities20,
+      apiFamily: "openai-completions",
+      provider: "llamacpp",
+      baseUrlForTarget: withV1
+    });
+  },
+  async rerank(target, query, documents, ctx) {
+    const base = targetUrl4(target);
+    if (!base) throw new Error("target has no url");
+    const modelId = target.defaultModel ?? "default";
+    const req = {
+      url: `${base}/reranking`,
+      method: "POST",
+      timeoutMs: ctx.httpTimeoutMs,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        query,
+        documents,
+        top_n: documents.length,
+        model: modelId
+      })
+    };
+    const result = await (ctx.signal ? probeJson({ ...req, signal: ctx.signal }) : probeJson(req));
+    if (!result.ok || !result.data) {
+      throw new Error(`llama.cpp rerank failed: ${result.error ?? "unknown"}`);
+    }
+    const rows = result.data.results ?? [];
+    const items = rows.map((row) => {
+      const idx = typeof row.index === "number" ? row.index : 0;
+      const score = typeof row.relevance_score === "number" ? row.relevance_score : 0;
+      const doc = typeof row.document === "string" ? row.document : typeof row.document?.text === "string" ? row.document.text : void 0;
+      const item = { index: idx, score };
+      if (doc !== void 0) item.document = doc;
+      return item;
+    });
+    return { items, model: result.data.model ?? modelId };
+  }
+};
+var llamacpp_rerank_default = llamacppRerankRuntime;
+
+// src/domains/providers/runtimes/local-native/lmstudio.ts
+init_esm_shims();
+
+// src/domains/providers/runtimes/common/lmstudio-http.ts
+init_esm_shims();
+import { performance as performance3 } from "node:perf_hooks";
+var catalogsByHost = /* @__PURE__ */ new Map();
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function positiveNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function nonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function lmStudioRootUrl(url2) {
+  const normalized = targetRootUrl({ id: "lmstudio", runtime: "lmstudio", url: url2 });
+  if (!normalized) return "";
+  if (normalized.startsWith("ws://")) return `http://${normalized.slice("ws://".length)}`;
+  if (normalized.startsWith("wss://")) return `https://${normalized.slice("wss://".length)}`;
+  return normalized;
+}
+function lmStudioRequestHeaders(base, apiKey) {
+  const headers = { ...base ?? {} };
+  const token = apiKey?.trim();
+  if (token) headers.authorization = `Bearer ${token}`;
+  return headers;
+}
+function lmStudioProbeHeaders(target, ctx) {
+  let token = ctx.authToken?.trim();
+  const envName = target.auth?.apiKeyEnvVar;
+  if (!token && envName && ctx.credentialsPresent.has(envName)) token = process.env[envName]?.trim();
+  return lmStudioRequestHeaders(target.auth?.headers, token);
+}
+function combinedSignal(timeoutMs, signal) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
+  const onAbort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) controller.abort(signal.reason);
+  else signal?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    close() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+async function requestLmStudioJson(url2, init, timeoutMs, signal) {
+  const started = performance3.now();
+  const bounded = combinedSignal(timeoutMs, signal);
+  try {
+    const response = await fetch(url2, { ...init, signal: bounded.signal });
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      data = void 0;
+    }
+    const result = {
+      ok: response.ok,
+      status: response.status,
+      latencyMs: Math.round(performance3.now() - started)
+    };
+    if (data !== void 0) result.data = data;
+    if (!response.ok) {
+      const message = isRecord3(data) ? nonEmptyString2(data.error) : void 0;
+      result.error = message ?? `HTTP ${response.status}`;
+    }
+    return result;
+  } catch (error) {
+    return {
+      ok: false,
+      status: 0,
+      latencyMs: Math.round(performance3.now() - started),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    bounded.close();
+  }
+}
+function loadedInstances(value) {
+  if (!Array.isArray(value)) return [];
+  const instances = [];
+  for (const raw of value) {
+    if (!isRecord3(raw)) continue;
+    const id = nonEmptyString2(raw.id);
+    if (!id) continue;
+    instances.push({ id, config: isRecord3(raw.config) ? { ...raw.config } : {} });
+  }
+  return instances;
+}
+function reasoningOptions(capabilities2) {
+  if (!isRecord3(capabilities2) || !isRecord3(capabilities2.reasoning)) return void 0;
+  const allowed = capabilities2.reasoning.allowed_options;
+  if (!Array.isArray(allowed)) return void 0;
+  const options = allowed.filter((entry) => typeof entry === "string");
+  return options.length > 0 ? options : void 0;
+}
+function parseLmStudioV1Models(data) {
+  if (!isRecord3(data) || !Array.isArray(data.models)) return null;
+  const models = [];
+  for (const raw of data.models) {
+    if (!isRecord3(raw)) continue;
+    const key = nonEmptyString2(raw.key);
+    if (!key) continue;
+    const capabilities2 = isRecord3(raw.capabilities) ? raw.capabilities : void 0;
+    const info = {
+      key,
+      loadedInstances: loadedInstances(raw.loaded_instances),
+      metadata: { ...raw }
+    };
+    const type = nonEmptyString2(raw.type);
+    if (type) info.type = type;
+    const maxContextLength = positiveNumber2(raw.max_context_length);
+    if (maxContextLength !== void 0) info.maxContextLength = maxContextLength;
+    if (capabilities2 && typeof capabilities2.vision === "boolean") info.vision = capabilities2.vision;
+    else if (type) info.vision = type === "vlm";
+    if (capabilities2 && typeof capabilities2.trained_for_tool_use === "boolean") {
+      info.tools = capabilities2.trained_for_tool_use;
+    }
+    const options = reasoningOptions(capabilities2);
+    if (options) info.reasoningOptions = options;
+    if (capabilities2 && "reasoning" in capabilities2) {
+      info.reasoning = capabilities2.reasoning === true || isRecord3(capabilities2.reasoning);
+    }
+    models.push(info);
+  }
+  return models;
+}
+function foldLmStudioModels(models) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const previous = byKey.get(model.key);
+    if (!previous) {
+      byKey.set(model.key, { ...model, loadedInstances: [...model.loadedInstances] });
+      continue;
+    }
+    const knownIds = new Set(previous.loadedInstances.map((instance) => instance.id));
+    for (const instance of model.loadedInstances) {
+      if (!knownIds.has(instance.id)) previous.loadedInstances.push(instance);
+    }
+    if (previous.maxContextLength === void 0 && model.maxContextLength !== void 0) {
+      previous.maxContextLength = model.maxContextLength;
+    }
+    if (previous.vision === void 0 && model.vision !== void 0) previous.vision = model.vision;
+    if (previous.tools === void 0 && model.tools !== void 0) previous.tools = model.tools;
+    if (previous.reasoningOptions === void 0 && model.reasoningOptions !== void 0) {
+      previous.reasoningOptions = model.reasoningOptions;
+    }
+    if (previous.reasoning === void 0 && model.reasoning !== void 0) previous.reasoning = model.reasoning;
+  }
+  return [...byKey.values()];
+}
+function rememberHostCatalog(target, models) {
+  const rootUrl = lmStudioRootUrl(target.url ?? "");
+  if (!rootUrl) return;
+  catalogsByHost.set(rootUrl, { targetId: target.id, rootUrl, models: foldLmStudioModels(models) });
+}
+function peerTargetsFor(target, instanceId) {
+  const rootUrl = lmStudioRootUrl(target.url ?? "");
+  const peers = [];
+  for (const catalog of catalogsByHost.values()) {
+    if (catalog.rootUrl === rootUrl) continue;
+    if (catalog.models.some((model) => model.loadedInstances.some((instance) => instance.id === instanceId))) {
+      peers.push(catalog.targetId);
+    }
+  }
+  return [...new Set(peers)];
+}
+function resolveLmStudioInstance(target, models, requestedId, configuredDefault) {
+  const folded = foldLmStudioModels(models);
+  for (const model of folded) {
+    const explicit = model.loadedInstances.find((instance2) => instance2.id === requestedId);
+    if (explicit) {
+      return {
+        requestedId,
+        wireModelId: explicit.id,
+        model,
+        instance: explicit,
+        peerTargets: peerTargetsFor(target, explicit.id),
+        state: "instance"
+      };
+    }
+    if (model.key !== requestedId) continue;
+    if (model.loadedInstances.length === 0) {
+      return { requestedId, wireModelId: requestedId, model, peerTargets: [], state: "jit" };
+    }
+    const preferred = configuredDefault ? model.loadedInstances.find((instance2) => instance2.id === configuredDefault) : void 0;
+    const local = model.loadedInstances.find((instance2) => peerTargetsFor(target, instance2.id).length === 0);
+    const instance = preferred ?? local ?? model.loadedInstances[0];
+    if (!instance) return { requestedId, wireModelId: requestedId, model, peerTargets: [], state: "jit" };
+    return {
+      requestedId,
+      wireModelId: instance.id,
+      model,
+      instance,
+      peerTargets: peerTargetsFor(target, instance.id),
+      state: "instance"
+    };
+  }
+  return { requestedId, wireModelId: requestedId, peerTargets: [], state: "unknown" };
+}
+function lmStudioReasoningLevels(options) {
+  if (!options || options.length === 0) return [...THINKING_LEVELS];
+  if (options.includes("on") && !options.includes("low") && !options.includes("medium") && !options.includes("high")) {
+    return ["off", "low"];
+  }
+  const levels = ["off"];
+  if (options.includes("low")) levels.push("minimal", "low");
+  if (options.includes("medium")) levels.push("medium");
+  if (options.includes("high")) levels.push("high", "xhigh", "max");
+  return [...new Set(levels)];
+}
+function lmStudioReasoningEffort(level, options) {
+  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";
+}
+function v0Models(data) {
+  if (!isRecord3(data) || !Array.isArray(data.data)) return null;
+  const models = [];
+  for (const raw of data.data) {
+    if (!isRecord3(raw)) continue;
+    const key = nonEmptyString2(raw.id);
+    if (!key) continue;
+    const state = nonEmptyString2(raw.state);
+    const loadedContext = positiveNumber2(raw.loaded_context_length);
+    const config = loadedContext === void 0 ? {} : { context_length: loadedContext };
+    const info = {
+      key,
+      loadedInstances: state === "loaded" || loadedContext !== void 0 ? [{ id: key, config }] : [],
+      metadata: { ...raw }
+    };
+    const type = nonEmptyString2(raw.type);
+    if (type) {
+      info.type = type;
+      info.vision = type === "vlm";
+    }
+    const maxContextLength = positiveNumber2(raw.max_context_length);
+    if (maxContextLength !== void 0) info.maxContextLength = maxContextLength;
+    if (Array.isArray(raw.capabilities)) info.tools = raw.capabilities.includes("tool_use");
+    models.push(info);
+  }
+  return models;
+}
+function openAIModels(data) {
+  if (!isRecord3(data) || !Array.isArray(data.data)) return null;
+  const models = [];
+  for (const raw of data.data) {
+    if (!isRecord3(raw)) continue;
+    const key = nonEmptyString2(raw.id);
+    if (key) models.push({ key, loadedInstances: [], metadata: { ...raw } });
+  }
+  return models;
+}
+function authFailure(result) {
+  if (result.status !== 401 && result.status !== 403) return null;
+  return {
+    ok: false,
+    models: [],
+    latencyMs: result.latencyMs,
+    error: "LM Studio authentication required",
+    authRequired: true
+  };
+}
+async function listLmStudioModels(target, ctx) {
+  if (!target.url) return { ok: false, models: [], error: "target has no url" };
+  const root = lmStudioRootUrl(target.url);
+  const headers = lmStudioProbeHeaders(target, ctx);
+  const init = { headers };
+  const v1 = await requestLmStudioJson(`${root}/api/v1/models`, init, ctx.httpTimeoutMs, ctx.signal);
+  const v1Auth = authFailure(v1);
+  if (v1Auth) return v1Auth;
+  const parsedV1 = parseLmStudioV1Models(v1.data);
+  if (v1.ok && parsedV1) {
+    rememberHostCatalog(target, parsedV1);
+    return { ok: true, models: parsedV1, tier: "0.4+", latencyMs: v1.latencyMs };
+  }
+  const v0 = await requestLmStudioJson(`${root}/api/v0/models`, init, ctx.httpTimeoutMs, ctx.signal);
+  const v0Auth = authFailure(v0);
+  if (v0Auth) return v0Auth;
+  const parsedV0 = v0Models(v0.data);
+  if (v0.ok && parsedV0) {
+    rememberHostCatalog(target, parsedV0);
+    return { ok: true, models: parsedV0, tier: "0.3.x", latencyMs: v0.latencyMs };
+  }
+  const openAI = await requestLmStudioJson(`${root}/v1/models`, init, ctx.httpTimeoutMs, ctx.signal);
+  const openAIAuth = authFailure(openAI);
+  if (openAIAuth) return openAIAuth;
+  const parsedOpenAI = openAIModels(openAI.data);
+  if (openAI.ok && parsedOpenAI) {
+    rememberHostCatalog(target, parsedOpenAI);
+    return { ok: true, models: parsedOpenAI, tier: "openai-compat", latencyMs: openAI.latencyMs };
+  }
+  return {
+    ok: false,
+    models: [],
+    latencyMs: v1.latencyMs + v0.latencyMs + openAI.latencyMs,
+    error: v1.error ?? v0.error ?? openAI.error ?? "LM Studio returned no recognized model catalog"
+  };
+}
+async function greetLmStudio(target, ctx) {
+  if (!target.url) return { ok: false, error: "target has no url" };
+  const result = await requestLmStudioJson(
+    `${lmStudioRootUrl(target.url)}/lmstudio-greeting`,
+    { headers: lmStudioProbeHeaders(target, ctx) },
+    ctx.httpTimeoutMs,
+    ctx.signal
+  );
+  if (result.ok && isRecord3(result.data) && result.data.lmstudio === true) {
+    return { ok: true, latencyMs: result.latencyMs };
+  }
+  return { ok: false, latencyMs: result.latencyMs, error: result.error ?? "endpoint did not return {lmstudio:true}" };
+}
+function loadedContextLength(instance) {
+  return positiveNumber2(instance?.config.context_length);
+}
+
+// src/domains/providers/runtimes/local-native/lmstudio.ts
+var defaultCapabilities21 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  structuredOutputs: "json-schema",
+  reasoning: true,
+  vision: true,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var reasoningOptionsByTargetModel = /* @__PURE__ */ new Map();
+function reasoningOptionsKey(target, modelId) {
+  const url2 = (target.url ?? "").replace(/^ws:/u, "http:").replace(/^wss:/u, "https:").replace(/\/$/u, "");
+  return `${target.id}|${url2}|${modelId}`;
+}
+function rememberReasoningOptions(target, models) {
+  const prefix = reasoningOptionsKey(target, "");
+  for (const key of reasoningOptionsByTargetModel.keys()) {
+    if (key.startsWith(prefix)) reasoningOptionsByTargetModel.delete(key);
+  }
+  for (const model of models) {
+    if (!model.reasoningOptions) continue;
+    reasoningOptionsByTargetModel.set(reasoningOptionsKey(target, model.key), model.reasoningOptions);
+    for (const instance of model.loadedInstances) {
+      reasoningOptionsByTargetModel.set(reasoningOptionsKey(target, instance.id), model.reasoningOptions);
+    }
+  }
+}
+function configuredModel(target) {
+  const id = target.defaultModel?.trim();
+  return id && id.length > 0 ? id : void 0;
+}
+function resolveModel(models, id) {
+  if (id) {
+    for (const model2 of models) {
+      if (model2.key === id) return { model: model2, ...model2.loadedInstances[0] ? { instance: model2.loadedInstances[0] } : {} };
+      const instance = model2.loadedInstances.find((entry) => entry.id === id);
+      if (instance) return { model: model2, instance };
+    }
+    return null;
+  }
+  const model = models.find((entry) => entry.loadedInstances.length > 0) ?? models[0];
+  return model ? { model, ...model.loadedInstances[0] ? { instance: model.loadedInstances[0] } : {} } : null;
+}
+function capabilities(model, instance) {
+  const out = {};
+  if (model.vision !== void 0) out.vision = model.vision;
+  if (model.tools !== void 0) out.tools = model.tools;
+  if (model.reasoning !== void 0) out.reasoning = model.reasoning;
+  else if (model.reasoningOptions !== void 0)
+    out.reasoning = model.reasoningOptions.some((option) => option !== "off");
+  const contextWindow = loadedContextLength(instance) ?? model.maxContextLength;
+  if (contextWindow !== void 0) out.contextWindow = contextWindow;
+  return out;
+}
+function statusFor(model, instance, reasoningLevels) {
+  const status = {
+    state: instance ? "loaded" : "unloaded",
+    key: model.key,
+    reasoningLevels
+  };
+  if (instance) {
+    status.instanceId = instance.id;
+    status.loadConfig = instance.config;
+    const contextLength = loadedContextLength(instance);
+    if (contextLength !== void 0) status.contextLength = contextLength;
+  }
+  return status;
+}
+function probeFromCatalog(catalog, target) {
+  if (!catalog.ok) {
+    return {
+      ok: false,
+      ...catalog.latencyMs !== void 0 ? { latencyMs: catalog.latencyMs } : {},
+      error: catalog.error ?? "LM Studio model listing failed"
+    };
+  }
+  const models = foldLmStudioModels(catalog.models);
+  rememberReasoningOptions(target, models);
+  const ids = [];
+  const modelCapabilities = {};
+  const modelStates = {};
+  for (const model of models) {
+    const levels = lmStudioReasoningLevels(model.reasoningOptions);
+    const keyInstance = model.loadedInstances[0];
+    modelCapabilities[model.key] = capabilities(model, keyInstance);
+    modelStates[model.key] = statusFor(model, keyInstance, levels);
+    for (const instance of model.loadedInstances) {
+      if (!ids.includes(instance.id)) ids.push(instance.id);
+      modelCapabilities[instance.id] = capabilities(model, instance);
+      const instanceStatus = statusFor(model, instance, levels);
+      modelStates[instance.id] = instanceStatus;
+      const resolution = resolveLmStudioInstance(target, models, instance.id, configuredModel(target));
+      instanceStatus.detail = resolution.peerTargets.length > 0 ? `loaded on ${target.id}; also loaded on ${resolution.peerTargets.join(", ")}` : `loaded on ${target.id}`;
+    }
+    if (model.loadedInstances.length === 0) {
+      ids.push(model.key);
+      const keyStatus = modelStates[model.key];
+      if (keyStatus) keyStatus.detail = "not loaded (LM Studio will load it on first use)";
+    }
+  }
+  const selected = resolveModel(models, configuredModel(target));
+  const result = {
+    ok: true,
+    models: ids,
+    modelCapabilities,
+    modelStates,
+    serverVersion: catalog.tier === "0.4+" ? "LM Studio API 0.4+" : catalog.tier === "0.3.x" ? "LM Studio API 0.3.x" : "LM Studio OpenAI-compatible API",
+    surfaces: {
+      openaiChat: "/v1/chat/completions",
+      ...catalog.tier === "0.4+" ? { nativeV1: "/api/v1/models" } : {},
+      ...catalog.tier === "0.3.x" ? { nativeV0: "/api/v0/models" } : {}
+    }
+  };
+  if (catalog.latencyMs !== void 0) result.latencyMs = catalog.latencyMs;
+  if (selected) {
+    result.discoveredCapabilities = capabilities(selected.model, selected.instance);
+    result.capabilityModelId = configuredModel(target) ?? selected.model.key;
+  }
+  const loaded = models.flatMap(
+    (model) => model.loadedInstances.map((instance) => {
+      const context = loadedContextLength(instance);
+      return `${model.key} as ${instance.id}${context ? ` at ${context} tokens` : ""}`;
+    })
+  );
+  result.notes = [
+    `LM Studio surface tier ${catalog.tier ?? "unknown"}`,
+    `Surfaces: ${Object.values(result.surfaces ?? {}).join(", ")}`,
+    ...loaded.length > 0 ? [`Loaded instances: ${loaded.join(", ")}`] : []
+  ];
+  return result;
+}
+var lmstudioRuntime = {
+  id: "lmstudio",
+  aliases: ["lmstudio-native"],
+  displayName: "LM Studio",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "openai-completions",
+  auth: "api-key",
+  defaultCapabilities: defaultCapabilities21,
+  async probe(target, ctx) {
+    const [greeting, catalog] = await Promise.all([greetLmStudio(target, ctx), listLmStudioModels(target, ctx)]);
+    if (!greeting.ok && catalog.tier !== "0.3.x") {
+      return {
+        ok: false,
+        ...greeting.latencyMs !== void 0 ? { latencyMs: greeting.latencyMs } : {},
+        error: `URL did not identify itself as LM Studio: ${greeting.error ?? "greeting missing"}`
+      };
+    }
+    return probeFromCatalog(catalog, target);
+  },
+  async probeModels(target, ctx) {
+    const catalog = await listLmStudioModels(target, ctx);
+    return probeFromCatalog(catalog, target).models ?? [];
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    const canonicalTarget = target.runtime === "lmstudio" ? target : { ...target, runtime: "lmstudio" };
+    const model = synthLocalModel({
+      target: canonicalTarget,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities21,
+      apiFamily: "openai-completions",
+      provider: "lmstudio",
+      baseUrlForTarget: (url2) => withV1(url2.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:"))
+    });
+    const metadata = model.clio;
+    if (metadata) {
+      metadata.chatTemplateKwargsUnsupported = true;
+      if (target.defaultModel) metadata.lmstudioDefaultModel = target.defaultModel;
+      const options = reasoningOptionsByTargetModel.get(reasoningOptionsKey(canonicalTarget, wireModelId));
+      if (options) metadata.lmstudioReasoningOptions = options;
+    }
+    return model;
+  }
+};
+var lmstudio_default = lmstudioRuntime;
+
+// src/domains/providers/runtimes/local-native/ollama-native.ts
+init_esm_shims();
+var defaultCapabilities22 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+function positiveNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+async function probeResidentModelStates(base, ctx) {
+  const opts = { url: `${base}/api/ps`, timeoutMs: ctx.httpTimeoutMs };
+  const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+  if (!result.ok || !result.data?.models) return void 0;
+  const states = {};
+  for (const row of result.data.models) {
+    const id = typeof row?.model === "string" ? row.model : typeof row?.name === "string" ? row.name : null;
+    if (!id) continue;
+    const status = { state: "loaded" };
+    const sizeVram = positiveNumber3(row?.size_vram);
+    if (sizeVram !== void 0) status.sizeVramBytes = sizeVram;
+    const size = positiveNumber3(row?.size);
+    if (size !== void 0) status.sizeBytes = size;
+    states[id] = status;
+  }
+  return Object.keys(states).length > 0 ? states : void 0;
+}
+var ollamaNativeRuntime = {
+  id: "ollama-native",
+  displayName: "Ollama (native)",
+  kind: "http",
+  tier: "local-native",
+  apiFamily: "ollama-native",
+  auth: "none",
+  defaultCapabilities: defaultCapabilities22,
+  async probe(target, ctx) {
+    const base = targetBaseUrl(target);
+    if (!base) return { ok: false, error: "target has no url" };
+    const opts = { url: `${base}/api/tags`, timeoutMs: ctx.httpTimeoutMs };
+    const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+    if (!result.ok) {
+      const failed = { ok: false };
+      if (result.error) failed.error = result.error;
+      if (result.latencyMs !== void 0) failed.latencyMs = result.latencyMs;
+      return failed;
+    }
+    const out = { ok: true };
+    if (result.latencyMs !== void 0) out.latencyMs = result.latencyMs;
+    const modelStates = await probeResidentModelStates(base, ctx);
+    if (modelStates) out.modelStates = modelStates;
+    return out;
+  },
+  async probeModels(target, ctx) {
+    const base = targetBaseUrl(target);
+    if (!base) return [];
+    const opts = { url: `${base}/api/tags`, timeoutMs: ctx.httpTimeoutMs };
+    const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
+    if (!result.ok || !result.data?.models) return [];
+    return result.data.models.map((row) => typeof row?.name === "string" ? row.name : null).filter((name) => name !== null);
+  },
+  synthesizeModel(target, wireModelId, kb) {
+    return synthLocalModel({
+      target,
+      wireModelId,
+      kb,
+      defaultCapabilities: defaultCapabilities22,
+      apiFamily: "ollama-native",
+      provider: "ollama",
+      baseUrlForTarget: withAsIs
+    });
+  }
+};
+var ollama_native_default = ollamaNativeRuntime;
+
+// src/domains/providers/runtimes/local-native/sglang.ts
+init_esm_shims();
+var defaultCapabilities23 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var sglang_default = makeOpenAICompatRuntime({
+  id: "sglang",
+  displayName: "SGLang",
+  provider: "sglang",
+  auth: "api-key",
+  tier: "local-native",
+  defaultCapabilities: defaultCapabilities23
+});
+
+// src/domains/providers/runtimes/local-native/vllm.ts
+init_esm_shims();
+var defaultCapabilities24 = {
+  chat: true,
+  tools: true,
+  toolCallFormat: "openai",
+  reasoning: false,
+  vision: false,
+  audio: false,
+  embeddings: false,
+  rerank: false,
+  fim: false,
+  contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+  maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS
+};
+var vllm_default = makeOpenAICompatRuntime({
+  id: "vllm",
+  displayName: "vLLM",
+  provider: "vllm",
+  auth: "api-key",
+  tier: "local-native",
+  defaultCapabilities: defaultCapabilities24,
+  healthPath: "/health"
+});
+
+// src/domains/providers/runtimes/builtins.ts
+var BUILTIN_RUNTIMES = [
+  alcf_default,
+  anthropic_default,
+  anthropic_max_default,
+  bedrock_default,
+  deepseek_default,
+  google_default,
+  groq_default,
+  mistral_default,
+  openai_default,
+  openai_codex_default,
+  openrouter_default,
+  lemonade_anthropic_default,
+  lemonade_openai_default,
+  llamacpp_default,
+  llamacpp_anthropic_default,
+  llamacpp_completion_default,
+  llamacpp_embed_default,
+  llamacpp_rerank_default,
+  lmstudio_default,
+  ollama_native_default,
+  anthropic_compat_default,
+  openai_compat_default,
+  sglang_default,
+  vllm_default,
+  claude_code_default,
+  claude_sdk_default,
+  antigravity_code_default
+];
+function registerBuiltinRuntimes(registry) {
+  for (const desc of BUILTIN_RUNTIMES) {
+    if (registry.get(desc.id) !== null) continue;
+    registry.register(desc);
+  }
+}
+
+export {
+  CLIO_MIN_CONTEXT_WINDOW,
+  CLIO_MIN_MAX_OUTPUT_TOKENS,
+  CLIO_CONTEXT_WINDOW_WARN_BELOW,
+  extractLocalModelQuirks,
+  lmStudioRootUrl,
+  requestLmStudioJson,
+  resolveLmStudioInstance,
+  lmStudioReasoningEffort,
+  listLmStudioModels,
+  greetLmStudio,
+  formatContextWindowSlots,
+  BUILTIN_RUNTIMES,
+  registerBuiltinRuntimes
+};
+//# sourceMappingURL=chunk-NMPKI6XL.js.map