@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/{chunk-ECOMVOHP.js → chunk-4DNL43EZ.js}

@@ -10,13 +10,13 @@ import {
   refKey,
   toolResultPayload,
   toolResultText
-} from "./chunk-DBREN25X.js";
+} from "./chunk-IPTPMLA6.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-O5F25NIE.js";
 import {
   ceilChars
-} from "./chunk-77CZRFTE.js";
+} from "./chunk-SJMNU4ZS.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -136,4 +136,4 @@ export {
   recallableRefListing,
   recallErrorMessage
 };
-//# sourceMappingURL=chunk-ECOMVOHP.js.map
+//# sourceMappingURL=chunk-4DNL43EZ.js.map

package/dist/{chunk-WT5TRMO4.js → chunk-4HFJKRGZ.js}

@@ -3,20 +3,26 @@ import {
   createSentinelStripper,
   stripTokenizerSentinels
 } from "./chunk-MCJKEGHO.js";
+import {
+  credentialsPresent
+} from "./chunk-CTGZCEI6.js";
+import {
+  getSharedBus
+} from "./chunk-RL7LJYN4.js";
 import {
   ceilChars,
   estimateAgentMessageTokens,
   toolSchemaChars
-} from "./chunk-77CZRFTE.js";
+} from "./chunk-SJMNU4ZS.js";
 import {
-  credentialsPresent
-} from "./chunk-VTYHHQ57.js";
+  BusChannels
+} from "./chunk-W5RM7YAH.js";
 import {
-  getSharedBus
-} from "./chunk-B5ZTR6KZ.js";
+  readSettings
+} from "./chunk-FPS4R2RN.js";
 import {
-  BusChannels
-} from "./chunk-6CB2IL4N.js";
+  warnLegacyNaming
+} from "./chunk-DVNAPPXU.js";
 import {
   CLIO_CONTEXT_WINDOW_WARN_BELOW,
   CLIO_MIN_CONTEXT_WINDOW,
@@ -33,17 +39,20 @@ import {
   registerBuiltinRuntimes,
   requestLmStudioJson,
   resolveLmStudioInstance
-} from "./chunk-SELG4SUR.js";
+} from "./chunk-NPLLK3HO.js";
 import {
   listKnownModelsForRuntime
-} from "./chunk-KS7ETA3P.js";
+} from "./chunk-EM2DIQAJ.js";
 import {
   authNotRequiredStatus,
   openAuthStorage,
   registerClioOAuthProviders,
   resolveAuthTarget,
   targetRequiresAuth
-} from "./chunk-6TAATXXH.js";
+} from "./chunk-ZKVMDNAN.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
 import {
   getRuntimeRegistry
 } from "./chunk-SRCEQKQS.js";
@@ -52,31 +61,19 @@ import {
   getCatalogModelForRuntime,
   mergeCapabilities,
   resolveCostProvenance
-} from "./chunk-TN5FW4XY.js";
+} from "./chunk-JIYWMQZ5.js";
 import {
   activateExternalPluginApiBridge,
   calculateEngineCost,
   ensurePiAiRegistered,
   registerEngineApiProvider
-} from "./chunk-5CMARGPF.js";
-import {
-  readSettings
-} from "./chunk-4QKAITQT.js";
-import {
-  warnLegacyNaming
-} from "./chunk-DVNAPPXU.js";
+} from "./chunk-UIU7MGZ3.js";
 import {
   sleep
 } from "./chunk-6EXUUOSN.js";
 import {
   withStateFileLock
 } from "./chunk-DVJL77SO.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -85,11 +82,29 @@ import {
   resolveClioDirs,
   stateRootRemoved
 } from "./chunk-CTTI7G3T.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
 import {
   __toESM,
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
 
+// src/domains/providers/types/cost-provenance.ts
+init_esm_shims();
+function normalizeCostProvenance(value) {
+  return value ?? "unknown";
+}
+var COST_PROVENANCE_VALUES = /* @__PURE__ */ new Set([
+  "known",
+  "known_free",
+  "estimated",
+  "unknown"
+]);
+function resolveCostProvenance2(value, fallback) {
+  return typeof value === "string" && COST_PROVENANCE_VALUES.has(value) ? value : fallback;
+}
+
 // src/domains/providers/endpoint-capacity.ts
 init_esm_shims();
 
@@ -135,8 +150,8 @@ function endpointSlotsTtlMs(env = process.env) {
 }
 function validRecord(key, value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const record = value;
-  return record.endpointKey === key && typeof record.runtimeId === "string" && record.runtimeId.length > 0 && typeof record.slots === "number" && Number.isInteger(record.slots) && record.slots > 0 && typeof record.observedAt === "string" && Number.isFinite(Date.parse(record.observedAt));
+  const record2 = value;
+  return record2.endpointKey === key && typeof record2.runtimeId === "string" && record2.runtimeId.length > 0 && typeof record2.slots === "number" && Number.isInteger(record2.slots) && record2.slots > 0 && typeof record2.observedAt === "string" && Number.isFinite(Date.parse(record2.observedAt));
 }
 function readRecords() {
   const path = endpointSlotsPath();
@@ -149,17 +164,17 @@ function readRecords() {
     return [];
   }
 }
-function fresh(record, nowMs, ttlMs) {
-  const observedMs = Date.parse(record.observedAt);
+function fresh(record2, nowMs, ttlMs) {
+  const observedMs = Date.parse(record2.observedAt);
   return observedMs <= nowMs && nowMs - observedMs < ttlMs;
 }
 function readDiscoveredEndpointSlots(options) {
   const nowMs = options?.nowMs ?? Date.now();
   const ttlMs = options?.ttlMs ?? endpointSlotsTtlMs();
   const out = {};
-  for (const record of readRecords()) {
-    if (!fresh(record, nowMs, ttlMs)) continue;
-    out[record.endpointKey] = record;
+  for (const record2 of readRecords()) {
+    if (!fresh(record2, nowMs, ttlMs)) continue;
+    out[record2.endpointKey] = record2;
   }
   return Object.freeze(out);
 }
@@ -167,7 +182,7 @@ function writeRecords(records) {
   const kept = [...records].sort((a, b) => Date.parse(b.observedAt) - Date.parse(a.observedAt)).slice(0, MAX_ENDPOINT_SLOT_RECORDS);
   const file = {
     version: 1,
-    endpoints: Object.fromEntries(kept.map((record) => [record.endpointKey, { ...record }]))
+    endpoints: Object.fromEntries(kept.map((record2) => [record2.endpointKey, { ...record2 }]))
   };
   safeResourceWrite(endpointSlotsPath(), `${JSON.stringify(file, null, 2)}
 `, { encoding: "utf8" });
@@ -182,7 +197,7 @@ async function recordDiscoveredEndpointSlots(entry, options) {
     await withStateFileLock(endpointSlotsPath(), () => {
       if (stateRootRemoved()) return;
       const kept = readRecords().filter(
-        (record) => record.endpointKey !== entry.endpointKey && fresh(record, nowMs, ttlMs)
+        (record2) => record2.endpointKey !== entry.endpointKey && fresh(record2, nowMs, ttlMs)
       );
       kept.push({
         endpointKey: entry.endpointKey,
@@ -754,13 +769,13 @@ function runOverrides(env = process.env) {
     return {};
   }
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-  const record = parsed;
+  const record2 = parsed;
   const out = {};
-  const maxContextTokens = record.maxContextTokens;
+  const maxContextTokens = record2.maxContextTokens;
   if (typeof maxContextTokens === "number" && Number.isInteger(maxContextTokens) && maxContextTokens > 0) {
     out.maxContextTokens = maxContextTokens;
   }
-  const sampling = record.sampling;
+  const sampling = record2.sampling;
   if (sampling !== null && typeof sampling === "object" && !Array.isArray(sampling)) {
     const numeric = {};
     for (const [key, value] of Object.entries(sampling)) {
@@ -1960,14 +1975,14 @@ function resolveRuntimeTarget(providers, input) {
 }
 function modelHintPatch(target, model) {
   if (!model || typeof model !== "object") return {};
-  const record = model;
+  const record2 = model;
   const patch = {};
-  if (!target.modelReasoningAuthoritative && typeof record.reasoning === "boolean") patch.reasoning = record.reasoning;
-  const contextWindow = nonNegativeFiniteNumber(record.contextWindow);
+  if (!target.modelReasoningAuthoritative && typeof record2.reasoning === "boolean") patch.reasoning = record2.reasoning;
+  const contextWindow = nonNegativeFiniteNumber(record2.contextWindow);
   if (contextWindow !== void 0 && target.capabilities.contextWindow <= 0) patch.contextWindow = contextWindow;
-  const maxTokens = nonNegativeFiniteNumber(record.maxTokens);
+  const maxTokens = nonNegativeFiniteNumber(record2.maxTokens);
   if (maxTokens !== void 0 && target.capabilities.maxTokens <= 0) patch.maxTokens = maxTokens;
-  if (Array.isArray(record.input)) patch.vision = record.input.includes("image");
+  if (Array.isArray(record2.input)) patch.vision = record2.input.includes("image");
   return patch;
 }
 function withoutStaleRuntimeDiagnostics(diagnostics, decisions) {
@@ -2135,21 +2150,6 @@ function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase
   };
 }
 
-// src/domains/providers/types/cost-provenance.ts
-init_esm_shims();
-function normalizeCostProvenance(value) {
-  return value ?? "unknown";
-}
-var COST_PROVENANCE_VALUES = /* @__PURE__ */ new Set([
-  "known",
-  "known_free",
-  "estimated",
-  "unknown"
-]);
-function resolveCostProvenance2(value, fallback) {
-  return typeof value === "string" && COST_PROVENANCE_VALUES.has(value) ? value : fallback;
-}
-
 // src/domains/providers/index.ts
 init_esm_shims();
 
@@ -2414,8 +2414,8 @@ function remainingContextMaxTokens(model, context, options, limits) {
 
 // src/engine/apis/sampling-overrides.ts
 init_esm_shims();
-function numberField(record, key) {
-  const value = record[key];
+function numberField(record2, key) {
+  const value = record2[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function runSamplingOverrides(env = process.env) {
@@ -2840,7 +2840,7 @@ var ollamaNativeApiProvider = {
 
 // src/engine/apis/openai-completions.ts
 init_esm_shims();
-import { TextDecoder } from "node:util";
+import { TextDecoder as TextDecoder2 } from "node:util";
 import {
   createAssistantMessageEventStream as createAssistantMessageEventStream3
 } from "@earendil-works/pi-ai";
@@ -2912,8 +2912,8 @@ function liteLLMGatewayRoutingFromHeaders(headers) {
   };
   return Object.keys(observation).length > 1 ? observation : null;
 }
-function gatewayRoutingObservationFromRecord(record) {
-  const value = record.gatewayRouting;
+function gatewayRoutingObservationFromRecord(record2) {
+  const value = record2.gatewayRouting;
   if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
   const raw = value;
   if (raw.gateway !== "litellm") return null;
@@ -3074,6 +3074,60 @@ function harmonyPrefixTailLength(value) {
   return 0;
 }
 
+// src/engine/provider-error-body.ts
+init_esm_shims();
+var SDK_BODY_CHARS = 4e3;
+var SDK_MARKER = /\.\.\. \[truncated (\d+) chars\]/u;
+var MAX_RESTORED_ERROR_BODY_CHARS = 65536;
+var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
+async function captureErrorBody(response) {
+  if (response.ok || response.body === null) return null;
+  try {
+    const reader = response.clone().body?.getReader();
+    if (reader === void 0) return null;
+    const decoder = new TextDecoder();
+    let text = "";
+    let bytes = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > MAX_CAPTURE_BYTES) {
+        await reader.cancel().catch(() => {
+        });
+        return null;
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+  } catch {
+    return null;
+  }
+}
+function restoreTruncatedErrorBody(message, capturedBody) {
+  if (capturedBody === null) return message;
+  const marker = SDK_MARKER.exec(message);
+  if (marker === null || marker.index < SDK_BODY_CHARS) return message;
+  let parsed;
+  try {
+    parsed = JSON.parse(capturedBody);
+  } catch {
+    return message;
+  }
+  const start = marker.index - SDK_BODY_CHARS;
+  const kept = message.slice(start, marker.index);
+  const dropped = Number(marker[1]);
+  const nested = typeof parsed === "object" && parsed !== null ? parsed.error : void 0;
+  for (const candidate of [nested, parsed]) {
+    if (typeof candidate !== "object" || candidate === null) continue;
+    const full = JSON.stringify(candidate).trim();
+    if (full.length - SDK_BODY_CHARS !== dropped || !full.startsWith(kept)) continue;
+    const restored = full.length > MAX_RESTORED_ERROR_BODY_CHARS ? `${full.slice(0, MAX_RESTORED_ERROR_BODY_CHARS)}... [truncated ${full.length - MAX_RESTORED_ERROR_BODY_CHARS} chars]` : full;
+    return `${message.slice(0, start)}${restored}${message.slice(marker.index + marker[0].length)}`;
+  }
+  return message;
+}
+
 // src/engine/apis/llamacpp-residency.ts
 init_esm_shims();
 import { performance } from "node:perf_hooks";
@@ -3606,6 +3660,7 @@ function captureResponseModelId(response, capture, model) {
   if (runtimeMetadata(model)?.runtimeId === "litellm") {
     capture.gatewayRouting = liteLLMGatewayRoutingFromHeaders(response.headers);
   }
+  if (!response.ok) capture.errorBody = captureErrorBody(response);
   if (!response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) {
     return response;
   }
@@ -3636,8 +3691,9 @@ function withResponseModelIdCapture(model, options, sourceFactory) {
     backendTimings: null,
     backendTimingsSource: backendTimingsSourceForModel(model),
     gatewayRouting: null,
+    errorBody: null,
     buffer: "",
-    decoder: new TextDecoder()
+    decoder: new TextDecoder2()
   };
   const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
   const capturedOptions = {
@@ -3655,6 +3711,9 @@ function withResponseModelIdCapture(model, options, sourceFactory) {
           if (capture.gatewayRouting !== null) event.message.gatewayRouting = capture.gatewayRouting;
           if (capture.backendTimings !== null) event.message.backendTimings = capture.backendTimings;
         } else if (event.type === "error") {
+          if (event.error.errorMessage !== void 0 && capture.errorBody !== null) {
+            event.error.errorMessage = restoreTruncatedErrorBody(event.error.errorMessage, await capture.errorBody);
+          }
           event.error.responseModelIdObservation = observation;
           if (capture.gatewayRouting !== null) event.error.gatewayRouting = capture.gatewayRouting;
           if (capture.backendTimings !== null) event.error.backendTimings = capture.backendTimings;
@@ -3836,23 +3895,23 @@ function applyLmStudioPayload(payload, model, resolved) {
   }
   return next;
 }
-function applyLlamaCppPromptCachePayload(payload, model) {
+function applyLlamaCppPromptCachePayload(payload, model, retention) {
   const metadata2 = runtimeMetadata(model);
   if (model.provider !== "llamacpp" || metadata2?.runtimeId !== "llamacpp") return payload;
   if (payload.cache_prompt !== void 0) return payload;
-  return { ...payload, cache_prompt: true };
+  return { ...payload, cache_prompt: retention !== "none" };
 }
 function shouldApplyLlamaCppPromptCache(model) {
   const metadata2 = runtimeMetadata(model);
   return model.provider === "llamacpp" && metadata2?.runtimeId === "llamacpp";
 }
-function composeThinkingOnPayload(resolved, base) {
+function composeThinkingOnPayload(resolved, base, retention) {
   return async (payload, model) => {
     if (!isPlainRecord(payload)) {
       return base ? await base(payload, model) : void 0;
     }
     const next = applyLmStudioPayload(
-      applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model), resolved.thinking, resolved, model),
+      applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model, retention), resolved.thinking, resolved, model),
       model,
       resolved
     );
@@ -3888,7 +3947,7 @@ function withSamplingOverrides(model, options, resolved) {
     };
   }
   if (promptCache || lmstudio || applied.mechanism === "effort-levels" || applied.mechanism === "budget-tokens" || applied.mechanism === "on-off" || applied.mechanism === "none") {
-    merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload);
+    merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload, options?.cacheRetention);
   }
   return merged;
 }
@@ -4401,16 +4460,10 @@ function resolveProviderKnowledgeBaseRoots(importMetaUrl, options = {}) {
 // src/domains/providers/plugins.ts
 init_esm_shims();
 import { join as join5 } from "node:path";
-function extractPluginPackages(settings) {
-  if (!settings || typeof settings !== "object") return [];
-  const raw = settings.runtimePlugins;
-  if (!Array.isArray(raw)) return [];
-  return raw.filter((entry) => typeof entry === "string" && entry.length > 0);
-}
 async function loadPluginRuntimes(registry, settings) {
   const loaded = [];
   const pluginDir = join5(clioConfigDir(), "runtimes");
-  const packages = extractPluginPackages(settings);
+  const packages = settings?.integrations.runtimePlugins ?? [];
   try {
     const ids = await registry.loadFromDir(pluginDir, activateExternalPluginApiBridge);
     loaded.push(...ids);
@@ -4680,6 +4733,7 @@ function createProvidersBundle(context) {
   const statuses = /* @__PURE__ */ new Map();
   const reasoningCache = /* @__PURE__ */ new Map();
   const unsubscribeConfigListeners = [];
+  let stopped = false;
   function reasoningCacheKey(targetId, modelId) {
     return `${targetId}:${modelId}`;
   }
@@ -4688,6 +4742,10 @@ function createProvidersBundle(context) {
     if (config) return config.get();
     return readSettings();
   }
+  function currentProbeTarget(probed) {
+    if (stopped) return void 0;
+    return readConfig().targets.find((target) => sameProbeIdentity(probed, target));
+  }
   async function buildProbeContextForTarget(target, desc, signal) {
     const probeCtx = {
       credentialsPresent: credentialsPresent(),
@@ -4731,6 +4789,7 @@ function createProvidersBundle(context) {
     return { available: false, reason: `missing auth (${envHint}store:${authTarget.providerId})` };
   }
   function buildStatus(target, desc, probe, previous) {
+    if (previous && !sameProbeIdentity(previous.target, target)) previous = void 0;
     if (!desc) {
       const out2 = {
         target,
@@ -4787,6 +4846,8 @@ function createProvidersBundle(context) {
   }
   async function probeTargetInternal(target, live, options) {
     options?.signal?.throwIfAborted();
+    if (stopped) return null;
+    target = structuredClone(target);
     const previous = statuses.get(target.id);
     const desc = registry.get(target.runtime);
     if (!desc) {
@@ -4802,6 +4863,7 @@ function createProvidersBundle(context) {
     }
     const probeCtx = await buildProbeContextForTarget(target, desc, options?.signal);
     options?.signal?.throwIfAborted();
+    if (!currentProbeTarget(target)) return null;
     let probeResult;
     try {
       probeResult = await desc.probe(target, probeCtx);
@@ -4809,6 +4871,7 @@ function createProvidersBundle(context) {
       probeResult = { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
     options?.signal?.throwIfAborted();
+    if (!currentProbeTarget(target)) return null;
     if (probeResult.ok && typeof desc.probeModels === "function" && !probeResult.models) {
       try {
         const ids = await desc.probeModels(target, probeCtx);
@@ -4817,6 +4880,7 @@ function createProvidersBundle(context) {
       }
     }
     options?.signal?.throwIfAborted();
+    if (!currentProbeTarget(target)) return null;
     if (probeResult.ok && options?.reasoning !== false && typeof desc.probeReasoning === "function") {
       const settings = readConfig();
       const orchestratorTarget = settings.chat.target === target.id ? settings.chat.model : null;
@@ -4825,6 +4889,7 @@ function createProvidersBundle(context) {
         try {
           const result = await desc.probeReasoning(target, candidateModelId, probeCtx);
           options?.signal?.throwIfAborted();
+          if (!currentProbeTarget(target)) return null;
           reasoningCache.set(reasoningCacheKey(target.id, candidateModelId), result.reasoning);
           const capabilityModelId = probeResult.capabilityModelId ?? null;
           if (capabilityModelId === null || capabilityModelId === candidateModelId) {
@@ -4846,7 +4911,9 @@ function createProvidersBundle(context) {
       }
     }
     options?.signal?.throwIfAborted();
-    const status = buildStatus(target, desc, probeResult, previous);
+    const current = currentProbeTarget(target);
+    if (!current) return null;
+    const status = buildStatus(current, desc, probeResult, previous);
     statuses.set(target.id, status);
     if (probeResult.ok && probeResult.models !== void 0) {
       recordTargetModelSnapshot(
@@ -4860,14 +4927,18 @@ function createProvidersBundle(context) {
     return status;
   }
   async function probeReasoningForModelInternal(targetId, modelId) {
+    if (stopped) return null;
     const settings = readConfig();
-    const target = settings.targets.find((ep) => ep.id === targetId);
-    if (!target) return null;
+    const configuredTarget = settings.targets.find((ep) => ep.id === targetId);
+    if (!configuredTarget) return null;
+    const target = structuredClone(configuredTarget);
     const desc = registry.get(target.runtime);
     if (!desc || typeof desc.probeReasoning !== "function") return null;
     const probeCtx = await buildProbeContextForTarget(target, desc);
+    if (!currentProbeTarget(target)) return null;
     try {
       const result = await desc.probeReasoning(target, modelId, probeCtx);
+      if (!currentProbeTarget(target)) return null;
       reasoningCache.set(reasoningCacheKey(targetId, modelId), result.reasoning);
       return result.reasoning;
     } catch {
@@ -4898,6 +4969,7 @@ function createProvidersBundle(context) {
   }
   const extension = {
     async start() {
+      stopped = false;
       ensurePiAiRegistered();
       registerClioApiProviders();
       registerClioOAuthProviders();
@@ -4918,6 +4990,7 @@ function createProvidersBundle(context) {
       }
     },
     async stop() {
+      stopped = true;
       for (const unsubscribe of unsubscribeConfigListeners.splice(0)) unsubscribe();
     }
   };
@@ -5018,6 +5091,105 @@ var ProvidersManifest = {
   dependsOn: ["config"]
 };
 
+// src/domains/providers/cache-deployment.ts
+init_esm_shims();
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function observeCacheDeployment(target, wireModelId, options = {}) {
+  const binding = target.cache?.deployment;
+  const observation = {
+    observedAt: Date.now(),
+    backend: binding?.backend ?? "unknown",
+    model: binding?.model ?? wireModelId,
+    build: null,
+    epoch: null,
+    endpoint: null,
+    requestControls: [],
+    warm: "unsupported",
+    administration: "unsupported",
+    reason: "deployment-unbound"
+  };
+  if (!binding) return observation;
+  try {
+    const control = new URL(binding.controlUrl);
+    if (!["http:", "https:"].includes(control.protocol) || control.username || control.password || control.search || control.hash) {
+      return { ...observation, reason: "deployment-invalid" };
+    }
+    const root = control.href.replace(/\/$/, "").replace(/\/v1$/, "");
+    observation.endpoint = canonicalEndpointUrl(root);
+    const signal = AbortSignal.any([AbortSignal.timeout(2e3), ...options.signal ? [options.signal] : []]);
+    const get = async (url, headers) => {
+      const response = await (options.fetchImpl ?? fetch)(url, {
+        method: "GET",
+        signal,
+        redirect: "error",
+        credentials: "omit",
+        ...headers ? { headers } : {}
+      });
+      if (!response.ok) throw new Error("discovery unavailable");
+      return await response.json();
+    };
+    const gateway = target.runtime === "litellm";
+    if (gateway) {
+      if (!binding.gatewayDeploymentId || !target.url) return { ...observation, reason: "gateway-unbound" };
+      const gatewayRoot = target.url.replace(/\/$/, "").replace(/\/v1$/, "");
+      const info = record(
+        await get(`${gatewayRoot}/v1/model/info`, {
+          ...target.auth?.headers,
+          ...options.gatewayApiKey ? { authorization: `Bearer ${options.gatewayApiKey}` } : {}
+        })
+      );
+      const rows = Array.isArray(info.data) ? info.data.map(record).filter((row2) => row2.model_name === wireModelId) : [];
+      const row = rows.length === 1 ? rows[0] : void 0;
+      const params = record(row?.litellm_params);
+      const modelInfo = record(row?.model_info);
+      if (!row || modelInfo.id !== binding.gatewayDeploymentId || params.model !== binding.model && params.model !== `openai/${binding.model}` || canonicalEndpointUrl(typeof params.api_base === "string" ? params.api_base : void 0) !== observation.endpoint) {
+        return { ...observation, reason: "gateway-route-mismatch" };
+      }
+    } else if (target.runtime !== binding.backend || wireModelId !== binding.model || canonicalEndpointUrl(target.url) !== observation.endpoint) {
+      return { ...observation, reason: "deployment-mismatch" };
+    }
+    if (binding.backend === "vllm") {
+      const version = record(await get(`${root}/version`));
+      observation.build = typeof version.version === "string" ? version.version : null;
+      return {
+        ...observation,
+        reason: observation.build === binding.build ? "vllm-scheduler-unverified" : "deployment-build-mismatch"
+      };
+    }
+    let props = record(await get(`${root}/props`));
+    const router = props.role === "router";
+    if (router) {
+      const models = record(await get(`${root}/models`));
+      const selected = Array.isArray(models.data) ? models.data.map(record).find((row) => row.id === binding.model) : void 0;
+      if (record(selected?.status).value !== "loaded") return { ...observation, reason: "model-not-loaded" };
+      props = record(await get(`${root}/props?model=${encodeURIComponent(binding.model)}&autoload=false`));
+    }
+    observation.build = typeof props.build_info === "string" ? props.build_info : null;
+    if (observation.build !== binding.build) return { ...observation, reason: "deployment-build-mismatch" };
+    if (!observation.build.endsWith("-c841aee"))
+      return { ...observation, reason: "deployment-cache-protocol-unverified" };
+    if (props.is_sleeping !== false) return { ...observation, reason: "model-not-loaded" };
+    if (typeof props.model_alias === "string" && props.model_alias !== binding.model)
+      return { ...observation, reason: "deployment-model-mismatch" };
+    if (!router) {
+      const models = record(await get(`${root}/v1/models`));
+      if (!Array.isArray(models.data) || models.data.length !== 1 || record(models.data[0]).id !== binding.model)
+        return { ...observation, reason: "deployment-model-mismatch" };
+    }
+    if (typeof props.start_time === "string") observation.epoch = props.start_time;
+    const slots = await get(`${root}/slots?model=${encodeURIComponent(binding.model)}&autoload=false`);
+    if (!Array.isArray(slots) || slots.length === 0 || slots.some((slot) => record(slot).is_processing !== false)) {
+      return { ...observation, reason: "endpoint-busy-or-unknown" };
+    }
+    if (gateway) return { ...observation, reason: "gateway-cache-transport-unverified" };
+    return { ...observation, requestControls: ["cache_prompt"], warm: "bounded", reason: "loaded-idle-deployment" };
+  } catch {
+    return { ...observation, reason: options.signal?.aborted ? "superseded" : "deployment-unavailable" };
+  }
+}
+
 // src/domains/providers/index.ts
 var ProvidersDomainModule = {
   manifest: ProvidersManifest,
@@ -5025,6 +5197,10 @@ var ProvidersDomainModule = {
 };
 
 export {
+  gatewayRoutingObservationFromRecord,
+  gatewayRoutingObservationLabel,
+  normalizeCostProvenance,
+  resolveCostProvenance2 as resolveCostProvenance,
   residencyTargetKey,
   setGlobalDefaultMaxOutputTokens,
   resolveReservedOutputTokens,
@@ -5040,8 +5216,6 @@ export {
   setResidencyNoticeSink,
   setProtectedModelsProvider,
   withRunOverrides,
-  gatewayRoutingObservationFromRecord,
-  gatewayRoutingObservationLabel,
   applyModelCapabilityPatch,
   probeCapabilitiesForModel,
   resolveModelCapabilities,
@@ -5056,6 +5230,7 @@ export {
   readTargetModelSnapshot,
   recordTargetModelSnapshot,
   FileKnowledgeBase,
+  observeCacheDeployment,
   isOrchestratorEligibleRuntime,
   isDispatchEligibleRuntime,
   modelResidencyForStatus,
@@ -5070,8 +5245,6 @@ export {
   firstRuntimeResolutionError,
   runtimeResolutionWarnings,
   runtimeResolutionWarningsBesideThinkingNotice,
-  normalizeCostProvenance,
-  resolveCostProvenance2 as resolveCostProvenance,
   ProvidersDomainModule
 };
-//# sourceMappingURL=chunk-WT5TRMO4.js.map
+//# sourceMappingURL=chunk-4HFJKRGZ.js.map