@iowarp/clio-coder 0.4.7 → 0.4.9

package/src/domains/providers/cache-deployment.ts

@@ -0,0 +1,147 @@
+import { canonicalEndpointUrl } from "../../core/endpoint-key.js";
+import type { TargetDescriptor } from "./types/target-descriptor.js";
+
+/** Fresh observations, not a persisted cache handle or permission to administer a server. */
+export interface CacheDeploymentObservation {
+	observedAt: number;
+	backend: "llamacpp" | "vllm" | "unknown";
+	model: string;
+	build: string | null;
+	/** Absent server epoch stays unknown; Clio never invents one from a build number. */
+	epoch: string | null;
+	endpoint: string | null;
+	requestControls: ReadonlyArray<"cache_prompt">;
+	warm: "bounded" | "unsupported";
+	administration: "unsupported";
+	reason: string;
+}
+
+function record(value: unknown): Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+/**
+ * Read-only admission evidence. Every invocation probes again, so an old route,
+ * build, resident state or process epoch is never reused to authorize a warm.
+ * Control-plane credentials are deliberately independent: this initial reader
+ * sends none. An authenticated/unknown control plane remains passive.
+ */
+export async function observeCacheDeployment(
+	target: TargetDescriptor,
+	wireModelId: string,
+	options: { signal?: AbortSignal; gatewayApiKey?: string; fetchImpl?: typeof fetch } = {},
+): Promise<CacheDeploymentObservation> {
+	const binding = target.cache?.deployment;
+	const observation: CacheDeploymentObservation = {
+		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(2000), ...(options.signal ? [options.signal] : [])]);
+		const get = async (url: string, headers?: Record<string, string>) => {
+			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()) as unknown;
+		};
+		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((row) => row.model_name === wireModelId) : [];
+			// Multiple replicas/fallback routes do not establish a single physical
+			// cache. A deployment response header arrives too late for admission.
+			const row = rows.length === 1 ? rows[0] : undefined;
+			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 : undefined) !== 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;
+			// APC and queue/memory metrics vary by deployment. A version and an
+			// OpenAI schema alone establish neither APC nor safe speculative load.
+			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)
+				: undefined;
+			if (record(selected?.status).value !== "loaded") return { ...observation, reason: "model-not-loaded" };
+			// Never wake sleeping models or load an absent worker during discovery.
+			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" };
+	}
+}

package/src/domains/providers/catalog.ts

@@ -148,7 +148,7 @@ export function synthesizeCatalogBackedModel(input: CatalogBackedSynthesisInput)
 	}
 	const pricing = input.target.pricing;
 	const targetHeaders = input.target.auth?.headers;
-	const model: Model<Api> = {
+	const model: Model<Api> & { clioCoder?: { cache: NonNullable<TargetDescriptor["cache"]> } } = {
 		...catalogFields,
 		id: input.wireModelId,
 		name: `${input.wireModelId} (${input.target.id})`,
@@ -160,14 +160,19 @@ export function synthesizeCatalogBackedModel(input: CatalogBackedSynthesisInput)
 			input.defaultBaseUrl,
 		reasoning: caps.reasoning,
 		input: caps.vision ? (builtin?.input.includes("image") ? builtin.input : ["text", "image"]) : ["text"],
-		cost: {
-			input: pricing?.input ?? builtin?.cost.input ?? 0,
-			output: pricing?.output ?? builtin?.cost.output ?? 0,
-			cacheRead: pricing?.cacheRead ?? builtin?.cost.cacheRead ?? 0,
-			cacheWrite: pricing?.cacheWrite ?? builtin?.cost.cacheWrite ?? 0,
-		},
+		// Catalog tiers belong to the catalog rates. An explicit target price
+		// replaces that schedule, using the same defaults as resolveEffectivePricing.
+		cost: pricing
+			? {
+					input: pricing.input,
+					output: pricing.output,
+					cacheRead: pricing.cacheRead ?? 0,
+					cacheWrite: pricing.cacheWrite ?? 0,
+				}
+			: structuredClone(builtin?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }),
 		contextWindow: caps.contextWindow,
 		maxTokens: caps.maxTokens,
+		...(input.target.cache === undefined ? {} : { clioCoder: { cache: structuredClone(input.target.cache) } }),
 	};
 	const headers = { ...(input.defaultHeaders ?? {}), ...(builtin?.headers ?? {}), ...(targetHeaders ?? {}) };
 	if (Object.keys(headers).length > 0) {

package/src/domains/providers/extension.ts

@@ -257,6 +257,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	const statuses = new Map<string, TargetStatus>();
 	const reasoningCache = new Map<string, boolean>();
 	const unsubscribeConfigListeners: Array<() => void> = [];
+	let stopped = false;
 
 	function reasoningCacheKey(targetId: string, modelId: string): string {
 		return `${targetId}:${modelId}`;
@@ -268,6 +269,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		return readSettings();
 	}
 
+	function currentProbeTarget(probed: TargetDescriptor): TargetDescriptor | undefined {
+		if (stopped) return undefined;
+		return readConfig().targets.find((target) => sameProbeIdentity(probed, target));
+	}
+
 	async function buildProbeContextForTarget(
 		target: TargetDescriptor,
 		desc: RuntimeDescriptor,
@@ -323,6 +329,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		probe: ProbeResult | null,
 		previous?: TargetStatus,
 	): TargetStatus {
+		if (previous && !sameProbeIdentity(previous.target, target)) previous = undefined;
 		if (!desc) {
 			const out: TargetStatus = {
 				target,
@@ -385,8 +392,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		target: TargetDescriptor,
 		live: boolean,
 		options?: { reasoning?: boolean; signal?: AbortSignal },
-	): Promise<TargetStatus> {
+	): Promise<TargetStatus | null> {
 		options?.signal?.throwIfAborted();
+		if (stopped) return null;
+		// A probe owns the descriptor it started with across asynchronous I/O.
+		target = structuredClone(target);
 		const previous = statuses.get(target.id);
 		const desc = registry.get(target.runtime);
 		if (!desc) {
@@ -402,6 +412,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		}
 		const probeCtx = await buildProbeContextForTarget(target, desc, options?.signal);
 		options?.signal?.throwIfAborted();
+		if (!currentProbeTarget(target)) return null;
 		let probeResult: ProbeResult;
 		try {
 			probeResult = await desc.probe(target, probeCtx);
@@ -409,6 +420,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			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);
@@ -418,6 +430,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			}
 		}
 		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;
@@ -426,6 +439,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				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) {
@@ -447,9 +461,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				}
 			}
 		}
-		// A cancelled role preparation must not publish failed/stale target state.
+		// Cancellation, target edits/removal, and shutdown revoke publication.
 		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 !== undefined) {
 			recordTargetModelSnapshot(
@@ -467,14 +483,18 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	}
 
 	async function probeReasoningForModelInternal(targetId: string, modelId: string): Promise<boolean | null> {
+		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 {
@@ -508,6 +528,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 
 	const extension: DomainExtension = {
 		async start() {
+			stopped = false;
 			ensurePiAiRegistered();
 			registerClioApiProviders();
 			registerClioOAuthProviders();
@@ -528,6 +549,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			}
 		},
 		async stop() {
+			stopped = true;
 			for (const unsubscribe of unsubscribeConfigListeners.splice(0)) unsubscribe();
 		},
 	};

package/src/domains/providers/index.ts

@@ -24,6 +24,7 @@ export {
 	resolveRuntimeAuthTarget,
 	targetRequiresAuth,
 } from "./auth/index.js";
+export { type CacheDeploymentObservation, observeCacheDeployment } from "./cache-deployment.js";
 export { AGENT_ROLE_TOOLS_REQUIRED_REASON, mergeCapabilities, supportsAgentRoleTools } from "./capabilities.js";
 export type { ProvidersContract, TargetHealth, TargetStatus } from "./contract.js";
 export { isDispatchEligibleRuntime, isOrchestratorEligibleRuntime, isTargetEligibleRuntime } from "./eligibility.js";
@@ -54,7 +55,11 @@ export {
 } from "./endpoint-slots-store.js";
 export { ProvidersManifest } from "./manifest.js";
 export type { ModelCapabilityPatchTarget } from "./model-capabilities.js";
-export { applyModelCapabilityPatch, resolveModelCapabilities } from "./model-capabilities.js";
+export {
+	applyModelCapabilityPatch,
+	probeCapabilitiesForModel,
+	resolveModelCapabilities,
+} from "./model-capabilities.js";
 export {
 	canonicalizeWireModelId,
 	contextSlotsForModel,

package/src/domains/providers/models/local-models/clio-coder-local-coding-targets.yaml

@@ -636,6 +636,37 @@
         turns when the workflow is iterative; the budget caps runaway chains.
     serving: "Official Qwen card recommends max output 32768 tokens for standard queries (81920 only for math/code competitions). Coding sampler is the precise variant; preserve thinking blocks across turns for iterative workflows."
 
+- family: qwopus3.8-27b-dense
+  matchPatterns:
+    - mini/qwopus3.8-27b-dense
+  capabilities:
+    reasoning: true
+  quirks:
+    measuredUnder:
+      runtime: "LiteLLM route mini/qwopus3.8-27b-dense-q6; model_info.runtime llama.cpp"
+      date: "2026-09-16"
+      source: "Operator report and current-source request to blade-gateway, reproduced during v0.4.9 closeout"
+      note: |
+        The exact route rejected an omitted effort with Jinja's diagnostic
+        Unexpected reasoning effort high. Supported types are xhigh
+        (default), medium, and low. Clio's captured request carried only
+        enable_thinking true. The upstream behavior is consistent with an
+        incompatible deployment default; its precise cause was not inspected.
+        These effort levels come from that server diagnostic, not from
+        Qwen or Qwopus name similarity. Other capabilities remain supplied
+        by the route probe; no sampler, hardware, or context size is inherited.
+    thinking:
+      mechanism: effort-levels
+      effortByLevel:
+        low: low
+        medium: medium
+        xhigh: xhigh
+      guidance: |
+        The measured mini/qwopus3.8-27b-dense-q6 route accepts low, medium,
+        and xhigh, and rejects high. Clio maps high and max to xhigh and
+        explicitly forwards that supported effort through LiteLLM. Omitting
+        active effort can expose an incompatible deployment default.
+
 - family: qwen3.8-27b
   matchPatterns:
     - qwen3.8-27b
@@ -829,23 +860,23 @@
     leakageNote: |
       LM Studio's gemma4 chat template emits chain-of-thought as plain text
       bracketed by literal '<|channel>thought\n' and '<channel|>' markers
-      rather than structured reasoning fragments. The OpenAI-compatible path
-      currently exposes those markers as the server streams them; filtering
-      this family remains a follow-up.
+      rather than structured reasoning fragments. Clio splits those regions into
+      thinking content on the OpenAI-compatible stream, including LM Studio,
+      and removes the channel markers from the visible answer.
     gpuTiers:
       "48gb": "Fits at f16 KV when parallel=1 and ctx=122880; drop to q8_0 KV at parallel=4."
       "80gb": "Comfortable at f16 KV with parallel=1 and ctx=122880."
     runtimePreference:
       lmstudio: "Pin parallel=1 in the LM Studio per-model preset to give a single agent the full 122880 context."
-      openaiCompat: "LM Studio chat uses this surface; visible text may contain the raw channel markers."
+      openaiCompat: "LM Studio chat uses this surface; Clio separates inline thought regions and removes their channel markers."
     thinking:
       mechanism: on-off
       guidance: |
         Gemma 4 chat template exposes thinking only as on or off; intermediate
         levels coerce to on. NVFP4 quantization can corrupt JSON tool-call
         output under aggressive sampling, so the instruct profile pins
-        temperature at 0.7. LM Studio's OpenAI-compatible stream currently
-        exposes channel markers when the server does not classify them.
+        temperature at 0.7. Clio classifies inline channel markers on LM Studio's
+        OpenAI-compatible stream when the server leaves them in content.
     serving: "LilaRest publishes no per-model sampler; values inherit the gemma family default per the official Google Gemma 4 31B card. KV cache budget at f16, ctx=122880 is roughly 57 GB on top of ~21 GB of NVFP4 weights."
 
 # The qat/UD-Q4_K_XL/MTP build is the long-context llama.cpp gemma profile and is a
@@ -928,7 +959,7 @@
       "32gb": "32 GB Vulkan llama.cpp profile with UD-Q4_K_XL weights, ctx=262144, q8 KV, flash attention, parallel=1, F16 gemma4v mmproj (vision), and MTP draft (spec-type draft-mtp, n_max 4) both active."
     runtimePreference:
       llamaCpp: "OpenAI-compatible chat completions with --jinja and --reasoning off. Recommended local profile serves at ctx=262144, q8 KV, flash attention, parallel=1, batch=1024, ubatch=256, with F16 mmproj vision and draft-mtp speculative decoding; sampler temperature 0.8, top_p 0.95, top_k 64, repeat_penalty 1.05."
-      openaiCompat: "Fallback when a gateway fronts the same llama.cpp chat-completions surface; the openai-compat surface does not expose the channel-marker classifier, so visible text may show raw thought markers."
+      openaiCompat: "Fallback when a gateway fronts the same llama.cpp chat-completions surface; Clio separates inline thought regions with the shared channel-marker filter."
     llamaCpp:
       ctxSize: 262144
       cacheTypeK: q8_0
@@ -1008,15 +1039,16 @@
       "48gb": "Fits at f16 KV with parallel=1; q8_0 KV recommended at parallel=4."
       "80gb": "Comfortable at f16 KV with parallel=1 and ctx=122880."
     runtimePreference:
-      lmstudio: "LM Studio's OpenAI-compatible stream may expose this family's channel markers as visible text."
+      lmstudio: "LM Studio may stream inline channel markers; Clio separates the thought region and removes the markers from the answer."
       openaiCompat: "Fallback; reasoning_content is absent from the openai-compat reasoning probe for this family."
     thinking:
       mechanism: always-on
       guidance: |
         Distilled traces emit unconditionally. The thinking level setting is
         ignored at the API surface; chain-of-thought arrives whether or not
-        Clio asks for it. Channel-marker filtering remains a follow-up for the
-        OpenAI-compatible LM Studio path.
+        Clio asks for it. The shared channel-marker filter splits inline thought
+        regions into thinking content on the OpenAI-compatible LM Studio path
+        and removes the markers from the visible answer.
     serving: "Distilled from Claude 4.6 Opus reasoning traces onto Google Gemma 4 31B; sampler matches the gemopus card values."
 
 - family: qwopus3.6-27b-v1-preview

package/src/domains/providers/plugins.ts

@@ -14,29 +14,19 @@
 
 import { join } from "node:path";
 
+import type { ClioSettings } from "../../core/config.js";
 import { clioConfigDir } from "../../core/xdg.js";
 import { activateExternalPluginApiBridge } from "../../engine/api-registry.js";
 import type { RuntimeRegistry } from "./registry.js";
 
-interface PluginSettings {
-	runtimePlugins?: unknown;
-}
-
-function extractPluginPackages(settings: unknown): string[] {
-	if (!settings || typeof settings !== "object") return [];
-	const raw = (settings as PluginSettings).runtimePlugins;
-	if (!Array.isArray(raw)) return [];
-	return raw.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
-}
-
 export async function loadPluginRuntimes(
 	registry: RuntimeRegistry,
-	settings?: unknown,
+	settings?: Pick<ClioSettings, "integrations">,
 ): Promise<ReadonlyArray<string>> {
 	const loaded: string[] = [];
 
 	const pluginDir = join(clioConfigDir(), "runtimes");
-	const packages = extractPluginPackages(settings);
+	const packages = settings?.integrations.runtimePlugins ?? [];
 	try {
 		const ids = await registry.loadFromDir(pluginDir, activateExternalPluginApiBridge);
 		loaded.push(...ids);

package/src/domains/providers/probe/http.ts

@@ -13,84 +13,69 @@ export interface HttpProbeOptions {
 
 export type JsonProbeOptions = HttpProbeOptions;
 
-export interface JsonProbeResult<T = unknown> extends ProbeResult {
-	data?: T;
+export interface HttpProbeResult extends ProbeResult {
+	/** Status of a completed HTTP response; absent when body/transport work fails. */
+	status?: number;
 }
 
-export async function probeHttp(opts: HttpProbeOptions): Promise<ProbeResult> {
-	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 };
-	// Some servers reject HEAD with 405 even though the endpoint is reachable.
-	if (method === "HEAD" && response.status === 405) return { ok: true, latencyMs };
-	return {
-		ok: false,
-		latencyMs,
-		error: `HTTP ${response.status}: ${response.statusText}`,
-	};
+export interface JsonProbeResult<T = unknown> extends HttpProbeResult {
+	data?: T;
 }
 
-export async function probeJson<T = unknown>(opts: JsonProbeOptions): Promise<JsonProbeResult<T>> {
-	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: T;
-	try {
-		data = (await response.json()) as T;
-	} catch (err) {
-		return { ok: false, latencyMs, error: `JSON parse: ${describeError(err)}` };
-	}
-	return { ok: true, latencyMs, data };
+export async function probeHttp(opts: HttpProbeOptions): Promise<HttpProbeResult> {
+	return runProbe(opts, false);
 }
 
-interface FetchOutcome {
-	response: Response | null;
-	latencyMs: number;
-	error?: string;
+export async function probeJson<T = unknown>(opts: JsonProbeOptions): Promise<JsonProbeResult<T>> {
+	return runProbe<T>(opts, true);
 }
 
-async function runFetch(opts: HttpProbeOptions): Promise<FetchOutcome> {
+/** Own the request until its body has been consumed or cancelled. */
+async function runProbe<T>(opts: HttpProbeOptions, readJson: boolean): Promise<JsonProbeResult<T>> {
 	const controller = new AbortController();
-	let timedOut = false;
-	const timer = setTimeout(() => {
-		timedOut = true;
+	let abortError: string | undefined;
+	const abort = (error: string): void => {
+		if (controller.signal.aborted) return;
+		abortError = error;
 		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: RequestInit = {
-		method: opts.method ?? "GET",
-		signal: controller.signal,
 	};
+	const timer = setTimeout(() => abort(`timeout after ${opts.timeoutMs}ms`), opts.timeoutMs);
+	const onExternalAbort = () => abort("aborted by caller");
+	if (opts.signal?.aborted) onExternalAbort();
+	else opts.signal?.addEventListener("abort", onExternalAbort, { once: true });
+	const method = opts.method ?? "GET";
+	const init: RequestInit = { method, signal: controller.signal };
 	if (opts.headers) init.headers = opts.headers;
 	if (opts.body !== undefined) init.body = opts.body;
 	const started = performance.now();
+	let latencyMs: number | undefined;
+	let parsingJson = false;
 	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` };
+		// Preserve the existing network latency measurement at response headers.
+		latencyMs = Math.round(performance.now() - started);
+		// HEAD 405 demonstrates reachability, but does not supply JSON data.
+		const ok = response.ok || (method === "HEAD" && response.status === 405);
+		if (!ok || !readJson) {
+			await response.body?.cancel();
+			controller.signal.throwIfAborted();
+			return ok
+				? { ok: true, latencyMs, status: response.status }
+				: { ok: false, latencyMs, status: response.status, error: `HTTP ${response.status}: ${response.statusText}` };
 		}
-		if (opts.signal?.aborted) {
-			return { response: null, latencyMs, error: "aborted by caller" };
-		}
-		return { response: null, latencyMs, error: describeError(err) };
+		parsingJson = true;
+		const data = (await response.json()) as T;
+		controller.signal.throwIfAborted();
+		return { ok: true, latencyMs, status: response.status, data };
+	} catch (err) {
+		return {
+			ok: false,
+			latencyMs: latencyMs ?? Math.round(performance.now() - started),
+			error: abortError ?? `${parsingJson ? "JSON parse: " : ""}${describeError(err)}`,
+		};
 	} finally {
 		clearTimeout(timer);
-		if (opts.signal) opts.signal.removeEventListener("abort", onExternalAbort);
+		opts.signal?.removeEventListener("abort", onExternalAbort);
 	}
 }
 

package/src/domains/providers/probe/reasoning.ts

@@ -95,6 +95,8 @@ export async function probeOpenAICompatReasoning(opts: ProbeReasoningOptions): P
 		});
 		const latencyMs = Math.round(performance.now() - started);
 		if (!response.ok) {
+			await response.body?.cancel();
+			controller.signal.throwIfAborted();
 			return { reasoning: false, latencyMs, error: `HTTP ${response.status}: ${response.statusText}` };
 		}
 		const data = (await response.json()) as ChatCompletionResponse;

package/src/domains/providers/runtimes/common/local-synth.ts

@@ -25,6 +25,7 @@ export interface ClioLocalModelMetadata {
 		chatTemplateKwargsUnsupported?: boolean;
 		lmstudio?: TargetDescriptor["lmstudio"];
 		litellm?: TargetDescriptor["litellm"];
+		cache?: TargetDescriptor["cache"];
 	};
 }
 
@@ -65,6 +66,8 @@ function localOpenAICompat(caps: CapabilityFlags, runtimeId: string): OpenAIComp
 		maxTokensField: "max_tokens",
 		supportsThinkingTokenBudget: runtimeId === "vllm",
 		supportsStrictMode: false,
+		// Native and generic gateway schemas do not establish hosted 24h retention.
+		supportsLongCacheRetention: false,
 	};
 	const thinkingFormat = openAIThinkingFormat(caps);
 	if (thinkingFormat) (compat as unknown as { thinkingFormat?: string }).thinkingFormat = thinkingFormat;
@@ -111,6 +114,7 @@ export function synthLocalModel(input: LocalSynthesisInput): Model<Api> {
 			...(quirks ? { quirks } : {}),
 			...(target.lmstudio ? { lmstudio: target.lmstudio } : {}),
 			...(target.litellm ? { litellm: target.litellm } : {}),
+			...(target.cache ? { cache: structuredClone(target.cache) } : {}),
 		},
 	};
 	if (headers) model.headers = headers;