@iowarp/clio-coder 0.4.9 → 0.5.0

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

@@ -1,14 +1,7 @@
 /**
- * Reasoning-capability probe for OpenAI-compatible HTTP endpoints.
- *
- * Local servers (LM Studio, llama.cpp, sglang, vllm, ...) advertise themselves
- * through an OpenAI-compatible surface regardless of whether the loaded model supports thinking.
- * Defaulting `caps.reasoning = false` means `/thinking` only ever surfaces
- * `["off"]` for these targets. Probing with a one-shot priming request reveals
- * the truth: a thinking-capable model emits a non-empty `reasoning_content`
- * (llama.cpp), `reasoning` (LM Studio + chat-templates), or `reasoning_text`
- * field in the streamed response. Caching the result per (target, model)
- * keeps the cost to a single round-trip per session.
+ * Explicit, generating reasoning qualification for OpenAI-compatible endpoints.
+ * Observing reasoning is positive evidence; an ordinary answer, error or timeout
+ * cannot establish that the model does not support reasoning.
  */
 import { performance } from "node:perf_hooks";
 
@@ -24,7 +17,7 @@ export interface ProbeReasoningOptions {
 }
 
 export interface ProbeReasoningResult {
-	reasoning: boolean;
+	reasoning: true | null;
 	field?: "reasoning_content" | "reasoning" | "reasoning_text";
 	latencyMs: number;
 	error?: string;
@@ -97,17 +90,17 @@ export async function probeOpenAICompatReasoning(opts: ProbeReasoningOptions): P
 		if (!response.ok) {
 			await response.body?.cancel();
 			controller.signal.throwIfAborted();
-			return { reasoning: false, latencyMs, error: `HTTP ${response.status}: ${response.statusText}` };
+			return { reasoning: null, latencyMs, error: `HTTP ${response.status}: ${response.statusText}` };
 		}
 		const data = (await response.json()) as ChatCompletionResponse;
 		const field = detectReasoningField(data);
 		if (field) return { reasoning: true, field, latencyMs };
-		return { reasoning: false, latencyMs };
+		return { reasoning: null, latencyMs };
 	} catch (err) {
 		const latencyMs = Math.round(performance.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) };
+		if (timedOut) return { reasoning: null, latencyMs, error: `timeout after ${opts.timeoutMs}ms` };
+		if (opts.signal?.aborted) return { reasoning: null, latencyMs, error: "aborted by caller" };
+		return { reasoning: null, latencyMs, error: err instanceof Error ? err.message : String(err) };
 	} finally {
 		clearTimeout(timer);
 		if (opts.signal) opts.signal.removeEventListener("abort", onExternalAbort);

package/src/domains/providers/probe/tool-call.ts

@@ -0,0 +1,236 @@
+/**
+ * Live tool-call probe. A target can list its models and still break on the
+ * first streamed tool call, which is the most common local-model failure. This
+ * probe sends one bounded request through the engine dispatcher a turn runs on,
+ * with the runtime's synthesized model, so it cannot pass while a turn fails.
+ *
+ * It generates tokens and can load a cold model, so callers run it only when
+ * the operator asked for it (`targets --probe --tools`).
+ */
+import { performance } from "node:perf_hooks";
+import { Type } from "typebox";
+import { streamSimple, validateEngineToolArguments } from "../../../engine/ai.js";
+import type { EngineModel } from "../../../engine/types.js";
+
+export const TOOL_PROBE_TOOL_NAME = "record_sum";
+
+const TOOL = {
+	name: TOOL_PROBE_TOOL_NAME,
+	description: "Record the sum of two integers.",
+	parameters: Type.Object(
+		{
+			a: Type.Integer({ description: "First addend." }),
+			b: Type.Integer({ description: "Second addend." }),
+		},
+		{ additionalProperties: false },
+	),
+};
+
+const PROMPT = `Call the ${TOOL_PROBE_TOOL_NAME} tool exactly once with a=2 and b=3. Do not answer in text.`;
+
+/** Enough for one small call, with room for a short preamble. */
+const MAX_TOKENS = 256;
+
+export interface ProbeToolCallOptions {
+	model: EngineModel;
+	timeoutMs: number;
+	apiKey?: string;
+	signal?: AbortSignal;
+	/** Test seam. Production uses the engine dispatcher a turn runs on. */
+	streamFn?: typeof streamSimple;
+}
+
+export interface ProbeToolCallResult {
+	ok: boolean;
+	/** More than one stream frame (or, when the transport is opaque, delta) arrived before done. */
+	streamed: boolean;
+	/** Frames the server sent for the response body; null when the transport was not observable. */
+	frames: number | null;
+	/** Content deltas the engine emitted before done. */
+	deltas: number;
+	toolCall: boolean;
+	/** Arguments parsed as JSON and matched the tool schema. */
+	argumentsValid: boolean;
+	latencyMs: number;
+	error?: string;
+}
+
+interface FrameCounter {
+	frames: number | null;
+}
+
+/**
+ * Count response frames at the transport: SSE `data:` events, or JSON lines
+ * for NDJSON. A single JSON body, pretty-printed or not, counts as one frame,
+ * so a server that ignores `stream: true` is caught whatever content type it
+ * claims.
+ */
+function framesIn(line: string): number {
+	if (line.startsWith("data:")) return line.slice(5).trim() === "[DONE]" ? 0 : 1;
+	return line.startsWith("{") ? 1 : 0;
+}
+
+function countingFetch(counter: FrameCounter): typeof fetch {
+	return async (input, init) => {
+		const response = await globalThis.fetch(input, init);
+		if ((init?.method ?? "GET").toUpperCase() !== "POST" || !response.ok || !response.body) return response;
+		counter.frames = 0;
+		const decoder = new TextDecoder();
+		let buffer = "";
+		const count = (text: string) => {
+			buffer += text;
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) counter.frames = (counter.frames ?? 0) + framesIn(line);
+		};
+		const body = response.body.pipeThrough(
+			new TransformStream<Uint8Array, Uint8Array>({
+				transform(chunk, controller) {
+					count(decoder.decode(chunk, { stream: true }));
+					controller.enqueue(chunk);
+				},
+				flush() {
+					count(`${decoder.decode()}\n`);
+				},
+			}),
+		);
+		return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+	};
+}
+
+interface ObservedCall {
+	name: string;
+	arguments: Record<string, unknown>;
+	raw: string;
+}
+
+function checkArguments(call: ObservedCall): string | null {
+	let args: unknown = call.arguments;
+	if (call.raw.trim().length > 0) {
+		try {
+			args = JSON.parse(call.raw);
+		} catch (err) {
+			return `tool call arguments are not valid JSON: ${err instanceof Error ? err.message : String(err)}`;
+		}
+	}
+	if (args === null || typeof args !== "object" || Array.isArray(args)) {
+		return "tool call arguments are not a JSON object";
+	}
+	try {
+		validateEngineToolArguments(TOOL, {
+			type: "toolCall",
+			id: "probe",
+			name: call.name,
+			arguments: args as Record<string, unknown>,
+		});
+		return null;
+	} catch (err) {
+		return `tool call arguments do not match the schema: ${err instanceof Error ? err.message : String(err)}`;
+	}
+}
+
+export async function probeToolCall(opts: ProbeToolCallOptions): Promise<ProbeToolCallResult> {
+	const controller = new AbortController();
+	let timedOut = false;
+	let rejectAbort: (reason: Error) => void = () => {};
+	const aborted = new Promise<never>((_, reject) => {
+		rejectAbort = reject;
+	});
+	// The race below settles the probe even if a transport ignores the signal.
+	aborted.catch(() => {});
+	const timer = setTimeout(() => {
+		timedOut = true;
+		controller.abort();
+		rejectAbort(new Error("timeout"));
+	}, opts.timeoutMs);
+	const onExternalAbort = () => {
+		controller.abort();
+		rejectAbort(new Error("aborted"));
+	};
+	if (opts.signal) {
+		if (opts.signal.aborted) onExternalAbort();
+		else opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+	}
+
+	const counter: FrameCounter = { frames: null };
+	let deltas = 0;
+	const raw = new Map<number, string>();
+	const calls: ObservedCall[] = [];
+	let argumentsValid = false;
+	const started = performance.now();
+	const outcome = (error?: string): ProbeToolCallResult => {
+		const result: ProbeToolCallResult = {
+			ok: error === undefined,
+			streamed: counter.frames !== null ? counter.frames > 1 : deltas > 1,
+			frames: counter.frames,
+			deltas,
+			toolCall: calls.length > 0,
+			argumentsValid,
+			latencyMs: Math.round(performance.now() - started),
+		};
+		if (error !== undefined) result.error = error;
+		return result;
+	};
+
+	const consume = async (): Promise<ProbeToolCallResult> => {
+		const send = opts.streamFn ?? streamSimple;
+		const context = {
+			systemPrompt: "You are a tool-calling test harness. Answer only with the requested tool call.",
+			messages: [{ role: "user", content: [{ type: "text", text: PROMPT }], timestamp: Date.now() }],
+			tools: [TOOL],
+		};
+		const options: Record<string, unknown> = {
+			maxTokens: MAX_TOKENS,
+			signal: controller.signal,
+			fetch: countingFetch(counter),
+		};
+		if (opts.apiKey !== undefined) options.apiKey = opts.apiKey;
+		const events = await send(
+			opts.model,
+			context as unknown as Parameters<typeof streamSimple>[1],
+			options as unknown as Parameters<typeof streamSimple>[2],
+		);
+		for await (const event of events) {
+			if (
+				(event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") &&
+				event.delta.length > 0
+			) {
+				deltas += 1;
+			}
+			if (event.type === "toolcall_delta") raw.set(event.contentIndex, (raw.get(event.contentIndex) ?? "") + event.delta);
+			if (event.type === "toolcall_end") {
+				calls.push({
+					name: event.toolCall.name,
+					arguments: event.toolCall.arguments,
+					raw: raw.get(event.contentIndex) ?? "",
+				});
+			}
+			if (event.type === "error") {
+				return outcome(event.error.errorMessage ?? "stream failed");
+			}
+			if (event.type === "done") break;
+		}
+		const first = calls[0];
+		if (!first) return outcome("no tool call in the response");
+		if (first.name !== TOOL_PROBE_TOOL_NAME) return outcome(`called unknown tool '${first.name}'`);
+		const argumentError = checkArguments(first);
+		if (argumentError) return outcome(argumentError);
+		argumentsValid = true;
+		if (!outcome().streamed) {
+			const seen = counter.frames !== null ? `${counter.frames} frame` : `${deltas} delta`;
+			return outcome(`response was not streamed (${seen}${seen.startsWith("1 ") ? "" : "s"} before done)`);
+		}
+		return outcome();
+	};
+
+	try {
+		return await Promise.race([consume(), aborted]);
+	} catch (err) {
+		if (timedOut) return outcome(`timeout after ${opts.timeoutMs}ms`);
+		if (opts.signal?.aborted) return outcome("aborted by caller");
+		return outcome(err instanceof Error ? err.message : String(err));
+	} finally {
+		clearTimeout(timer);
+		if (opts.signal) opts.signal.removeEventListener("abort", onExternalAbort);
+	}
+}

package/src/domains/providers/registry.ts

@@ -1,6 +1,8 @@
 import { readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { writeDiagnostic } from "../../core/diagnostics.js";
+import { warnLegacyNaming } from "../../core/naming-compat.js";
 
 import type { RuntimeDescriptor } from "./types/runtime-descriptor.js";
 
@@ -30,7 +32,11 @@ export function createRuntimeRegistry(): RuntimeRegistry {
 		canonical.add(desc.id);
 	};
 
-	const get = (id: string): RuntimeDescriptor | null => byId.get(id) ?? null;
+	const get = (id: string): RuntimeDescriptor | null => {
+		const runtime = byId.get(id) ?? null;
+		if (runtime && runtime.id !== id) warnLegacyNaming(id, runtime.id);
+		return runtime;
+	};
 
 	const list = (): ReadonlyArray<RuntimeDescriptor> =>
 		Array.from(canonical, (id) => byId.get(id)).filter((entry): entry is RuntimeDescriptor => entry !== undefined);
@@ -59,7 +65,7 @@ export function createRuntimeRegistry(): RuntimeRegistry {
 				register(desc);
 				loaded.push(desc.id);
 			} catch (err) {
-				process.stderr.write(`[providers] runtime plugin ${full} rejected: ${describeError(err)}\n`);
+				writeDiagnostic(`[providers] runtime plugin ${full} rejected: ${describeError(err)}\n`);
 			}
 		}
 		return loaded;
@@ -74,19 +80,19 @@ export function createRuntimeRegistry(): RuntimeRegistry {
 			await beforeImport?.();
 			mod = await import(packageName);
 		} catch (err) {
-			process.stderr.write(`[providers] runtime package ${packageName} failed to import: ${describeError(err)}\n`);
+			writeDiagnostic(`[providers] runtime package ${packageName} failed to import: ${describeError(err)}\n`);
 			return [];
 		}
 		const exported = (mod as { clioRuntimes?: unknown }).clioRuntimes;
 		if (!Array.isArray(exported)) {
-			process.stderr.write(`[providers] runtime package ${packageName} has no 'clioRuntimes' array export\n`);
+			writeDiagnostic(`[providers] runtime package ${packageName} has no 'clioRuntimes' array export\n`);
 			return [];
 		}
 		const loaded: string[] = [];
 		for (const candidate of exported) {
 			const validation = validateRuntimeDescriptor(candidate);
 			if (!validation.ok) {
-				process.stderr.write(
+				writeDiagnostic(
 					`[providers] runtime package ${packageName} exported an invalid descriptor: ${validation.reason}\n`,
 				);
 				continue;
@@ -95,7 +101,7 @@ export function createRuntimeRegistry(): RuntimeRegistry {
 				register(validation.descriptor);
 				loaded.push(validation.descriptor.id);
 			} catch (err) {
-				process.stderr.write(`[providers] runtime package ${packageName} id conflict: ${describeError(err)}\n`);
+				writeDiagnostic(`[providers] runtime package ${packageName} id conflict: ${describeError(err)}\n`);
 			}
 		}
 		return loaded;
@@ -111,6 +117,43 @@ export function getRuntimeRegistry(): RuntimeRegistry {
 	return singleton;
 }
 
+function normalizeRuntimeId(id: string): string {
+	return id.toLowerCase().replace(/[^a-z0-9]/gu, "");
+}
+
+function editDistance(a: string, b: string): number {
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i += 1) {
+		const current = [i];
+		for (let j = 1; j <= b.length; j += 1) {
+			const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+			current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
+		}
+		previous = current;
+	}
+	return previous[b.length] ?? 0;
+}
+
+/**
+ * The canonical id of the registered runtime closest to an unknown one, or
+ * null when nothing is near enough to be a plausible typo. Ids compare
+ * lowercased with separators dropped, so `lm-studio` and `llama.cpp` find their
+ * runtime, and a near miss of an alias suggests the canonical id it names.
+ */
+export function closestRuntimeId(registry: RuntimeRegistry, input: string): string | null {
+	const wanted = normalizeRuntimeId(input);
+	if (wanted.length === 0) return null;
+	const limit = Math.max(1, Math.floor(wanted.length / 3));
+	let best: { id: string; distance: number } | null = null;
+	for (const runtime of registry.list()) {
+		for (const id of [runtime.id, ...(runtime.aliases ?? [])]) {
+			const distance = editDistance(wanted, normalizeRuntimeId(id));
+			if (distance <= limit && (best === null || distance < best.distance)) best = { id: runtime.id, distance };
+		}
+	}
+	return best?.id ?? null;
+}
+
 async function importDescriptor(
 	file: string,
 	href: string,
@@ -121,13 +164,13 @@ async function importDescriptor(
 		await beforeImport?.();
 		mod = await import(href);
 	} catch (err) {
-		process.stderr.write(`[providers] runtime plugin ${file} failed to import: ${describeError(err)}\n`);
+		writeDiagnostic(`[providers] runtime plugin ${file} failed to import: ${describeError(err)}\n`);
 		return null;
 	}
 	const candidate = (mod as { default?: unknown }).default;
 	const validation = validateRuntimeDescriptor(candidate);
 	if (!validation.ok) {
-		process.stderr.write(
+		writeDiagnostic(
 			`[providers] runtime plugin ${file} has invalid default-export RuntimeDescriptor: ${validation.reason}\n`,
 		);
 		return null;

package/src/domains/providers/runtime-resolution.ts

@@ -105,6 +105,19 @@ export interface ResolvedRuntimeTarget {
 	diagnostics: RuntimeResolutionDiagnostic[];
 	runtimeTier?: RuntimeTier;
 	contextWindowDetails: ContextWindowDetails;
+	/**
+	 * Provenance of the `tools` decision when a live tool-call probe ran against
+	 * this exact model. Absent when `tools` is a declared or default capability.
+	 */
+	toolsVerification?: ToolsVerification;
+}
+
+export interface ToolsVerification {
+	source: "probe";
+	status: "verified" | "failed";
+	/** Epoch ms when the probe finished. */
+	checkedAt: number;
+	error?: string;
 }
 
 export interface RuntimeTargetSnapshot {
@@ -132,6 +145,7 @@ export interface RuntimeTargetSnapshot {
 	response: ResolvedModelRuntimeCapabilities["response"];
 	diagnostics: RuntimeResolutionDiagnostic[];
 	runtimeTier?: RuntimeTier;
+	toolsVerification?: ToolsVerification;
 }
 
 export type RuntimeTargetResolution =
@@ -476,6 +490,16 @@ export function resolveRuntimeTarget(
 	appendCapabilityDiagnostics(diagnostics, input, capabilities, decisions, targetId);
 	appendThinkingDiagnostics(diagnostics, modelRuntime, requestedThinkingLevel);
 	appendChatTemplateKwargsDiagnostics(diagnostics, modelRuntime);
+	const toolsVerification = toolsVerificationFor(status, wireModelId);
+	if (toolsVerification?.status === "failed") {
+		diagnostics.push(
+			diagnostic(
+				"warning",
+				"tools-probe-failed",
+				`target '${targetId}' model '${wireModelId}' failed the live tool-call probe: ${toolsVerification.error ?? "unknown error"}`,
+			),
+		);
+	}
 
 	if (hasError(diagnostics)) return { ok: false, diagnostics };
 
@@ -500,9 +524,19 @@ export function resolveRuntimeTarget(
 		contextWindowDetails,
 	};
 	if (runtime.tier !== undefined) resolved.runtimeTier = runtime.tier;
+	if (toolsVerification) resolved.toolsVerification = toolsVerification;
 	return { ok: true, target: resolved, diagnostics };
 }
 
+/** The live tool-call probe's answer for this exact model, when one ran and was not skipped. */
+function toolsVerificationFor(status: TargetStatus, wireModelId: string): ToolsVerification | null {
+	const probe = status.toolProbe;
+	if (!probe || probe.modelId !== wireModelId || probe.status === "skipped") return null;
+	const out: ToolsVerification = { source: "probe", status: probe.status, checkedAt: probe.checkedAt };
+	if (probe.error !== undefined) out.error = probe.error;
+	return out;
+}
+
 function modelHintPatch(target: ResolvedRuntimeTarget, model: unknown): Partial<CapabilityFlags> {
 	if (!model || typeof model !== "object") return {};
 	const record = model as Record<string, unknown>;
@@ -613,6 +647,7 @@ export function runtimeTargetSnapshot(target: ResolvedRuntimeTarget): RuntimeTar
 		diagnostics: target.diagnostics.map((entry) => ({ ...entry })),
 	};
 	if (target.runtimeTier !== undefined) snapshot.runtimeTier = target.runtimeTier;
+	if (target.toolsVerification !== undefined) snapshot.toolsVerification = { ...target.toolsVerification };
 	return snapshot;
 }
 
@@ -718,22 +753,35 @@ export function resolveContextWindowDetails(
 	const loadedWindow = positiveWindow(loadedContextWindow);
 	const probeWindow = positiveWindow(probedContextWindow);
 	const overrideWindow = positiveWindow(target.capabilities?.contextWindow);
+	const requestedWindow = positiveWindow(runtime.requestedContextWindow?.(target));
+	// Only a model maximum is capped here. A loaded window, an override, and a
+	// requested window each name what the server serves, and none of them is cold.
+	const coldCap = (maximum: number): number =>
+		Math.min(maximum, positiveWindow(runtime.coldContextWindowCap) ?? maximum);
 	let effective: number;
 	let source: ContextWindowSource;
-	if (loadedWindow !== undefined && (overrideWindow === undefined || loadedWindow <= overrideWindow)) {
+	if (requestedWindow !== undefined) {
+		// The window every request asks for (Ollama `num_ctx`) is the one the
+		// server will reload the model at, so a smaller loaded window is about to
+		// stop being true. A smaller override or model maximum still caps it.
+		effective = Math.min(requestedWindow, overrideWindow ?? requestedWindow, probeWindow ?? requestedWindow);
+		source = probeWindow === effective && effective < requestedWindow ? "probe" : "target-override";
+	} else if (loadedWindow !== undefined && (overrideWindow === undefined || loadedWindow <= overrideWindow)) {
 		effective = loadedWindow;
 		source = "loaded";
 	} else if (overrideWindow !== undefined) {
-		effective = overrideWindow;
-		source = "target-override";
+		// A declaration cannot enlarge an observed server limit, including a
+		// conservative limit retained after resident-state discovery failed.
+		effective = Math.min(overrideWindow, probeWindow ?? overrideWindow);
+		source = probeWindow !== undefined && probeWindow < overrideWindow ? "probe" : "target-override";
 	} else if (probeWindow !== undefined) {
-		effective = probeWindow;
+		effective = coldCap(probeWindow);
 		// Not "loaded": a probed window is what the target reported for the
 		// model, and only a runtime that names its resident instance's window
 		// has said anything about what is serving right now.
 		source = "probe";
 	} else if (modelDeclared !== undefined) {
-		effective = modelDeclared;
+		effective = coldCap(modelDeclared);
 		source = modelDeclaredSource;
 	} else {
 		effective = declaredContextWindow;
@@ -746,20 +794,20 @@ export function resolveContextWindowDetails(
 
 	// One-run CLI override (clio-coder run --max-context-tokens), delivered over the
 	// run-overrides transport; see core/run-overrides.ts.
+	const targetContextWindow = effective;
 	const overrideMaxContextTokens = runOverrides().maxContextTokens;
-	if (overrideMaxContextTokens !== undefined) {
+	if (overrideMaxContextTokens !== undefined && overrideMaxContextTokens < effective) {
 		effective = overrideMaxContextTokens;
 		source = "target-override";
 	}
 
-	// Below the floor is a warning on every tier. A target that reports less
-	// than Clio's minimum will compact on the first substantial read no matter
-	// where it runs, and the operator can act on that only if they are told.
+	// Warn about target capacity, not a deliberately smaller per-run budget.
+	// The latter does not mean that reloading the server would help.
 	let warning: string | null = null;
-	if (effective < CLIO_CONTEXT_WINDOW_WARN_BELOW) {
+	if (targetContextWindow < CLIO_CONTEXT_WINDOW_WARN_BELOW) {
 		warning =
-			`Target offers ${effective} context tokens, below the ${CLIO_CONTEXT_WINDOW_WARN_BELOW} Clio needs. ` +
-			`Load the model with a larger context, or set capabilities.contextWindow on this target.`;
+			`Target offers ${targetContextWindow} context tokens, below Clio's recommended ${CLIO_CONTEXT_WINDOW_WARN_BELOW}. ` +
+			`Load the model with a larger context; capabilities.contextWindow only declares an existing server limit.`;
 	}
 
 	// Deliberately not folded into `warning`. That field means the window is

package/src/domains/providers/runtimes/boot-manifest.ts

@@ -40,7 +40,7 @@ export const BUILTIN_RUNTIME_BOOT_MANIFEST: ReadonlyArray<RuntimeBootMetadata> =
 	{ id: "llamacpp-embed", kind: "http", tier: "local-native", auth: "api-key" },
 	{ id: "llamacpp-rerank", kind: "http", tier: "local-native", auth: "api-key" },
 	{ id: "lmstudio", aliases: ["lmstudio-native"], kind: "http", tier: "local-native", auth: "api-key" },
-	{ id: "ollama-native", kind: "http", tier: "local-native", auth: "none" },
+	{ id: "ollama", aliases: ["ollama-native"], kind: "http", tier: "local-native", auth: "none" },
 	{ id: "anthropic-compat", kind: "http", tier: "protocol", auth: "api-key" },
 	{ id: "litellm", kind: "http", tier: "protocol", auth: "api-key" },
 	{ id: "openai-compat", kind: "http", tier: "protocol", auth: "api-key" },

package/src/domains/providers/runtimes/builtins.ts

@@ -32,7 +32,7 @@ import llamacppCompletion from "./local-native/llamacpp-completion.js";
 import llamacppEmbed from "./local-native/llamacpp-embed.js";
 import llamacppRerank from "./local-native/llamacpp-rerank.js";
 import lmstudio from "./local-native/lmstudio.js";
-import ollamaNative from "./local-native/ollama-native.js";
+import ollama from "./local-native/ollama.js";
 import sglang from "./local-native/sglang.js";
 import vllm from "./local-native/vllm.js";
 import anthropicCompat from "./protocol/anthropic-compat.js";
@@ -59,7 +59,7 @@ const BUILTIN_RUNTIMES: ReadonlyArray<RuntimeDescriptor> = [
 	llamacppEmbed,
 	llamacppRerank,
 	lmstudio,
-	ollamaNative,
+	ollama,
 	anthropicCompat,
 	litellm,
 	openaiCompat,