@iowarp/clio-coder 0.3.0 → 0.3.1

package/src/domains/providers/runtimes/common/probe-helpers.ts

@@ -0,0 +1,474 @@
+import { probeHttp, probeJson } from "../../probe/http.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import type { ProbeContext, ProbeModelStatus, ProbeResult } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+
+export interface OpenAIModelsResponse {
+	data?: Array<Record<string, unknown> & { id?: unknown; status?: unknown }>;
+}
+
+export async function probeUrl(url: string, ctx: ProbeContext, method: "GET" | "HEAD" = "GET"): Promise<ProbeResult> {
+	const base = { url, timeoutMs: ctx.httpTimeoutMs, method } as const;
+	return ctx.signal ? probeHttp({ ...base, signal: ctx.signal }) : probeHttp(base);
+}
+
+export async function probeOpenAIModels(base: string, ctx: ProbeContext, modelsPath = "/v1/models"): Promise<string[]> {
+	return (await probeOpenAIModelCatalog(base, ctx, modelsPath)).models;
+}
+
+export interface OpenAIModelCatalogProbe {
+	models: string[];
+	modelCapabilities: Record<string, Partial<CapabilityFlags>>;
+	modelStates: Record<string, ProbeModelStatus>;
+}
+
+/**
+ * Vendor detail endpoints that describe the same models `/v1/models` lists,
+ * with the numbers `/v1/models` omits. LM Studio's `/api/v0/models` reports
+ * `max_context_length`, `loaded_context_length`, `state`, and `capabilities`;
+ * the OpenAI schema has nowhere to put any of them, so a self-hosted LM Studio
+ * reached over `openai-compat` looks like a target that declared nothing and
+ * Clio has to assume a window instead of reading one. Asking costs one GET
+ * that 404s harmlessly on servers that do not implement it.
+ */
+const OPENAI_COMPAT_DETAIL_PATHS: ReadonlyArray<string> = ["/api/v0/models"];
+
+async function probeModelDetailRows(
+	base: string,
+	ctx: ProbeContext,
+	modelsPath: string,
+): Promise<Map<string, Record<string, unknown>>> {
+	const rows = new Map<string, Record<string, unknown>>();
+	for (const detailPath of OPENAI_COMPAT_DETAIL_PATHS) {
+		if (detailPath === modelsPath) continue;
+		const opts = { url: `${base}${detailPath}`, timeoutMs: ctx.httpTimeoutMs } as const;
+		const result = await (ctx.signal
+			? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
+			: probeJson<OpenAIModelsResponse>(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;
+}
+
+export async function probeOpenAIModelCatalog(
+	base: string,
+	ctx: ProbeContext,
+	modelsPath = "/v1/models",
+): Promise<OpenAIModelCatalogProbe> {
+	const opts = { url: `${base}${modelsPath}`, timeoutMs: ctx.httpTimeoutMs } as const;
+	const result = await (ctx.signal
+		? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
+		: probeJson<OpenAIModelsResponse>(opts));
+	if (!result.ok || !result.data?.data) return { models: [], modelCapabilities: {}, modelStates: {} };
+	const detail = await probeModelDetailRows(base, ctx, modelsPath);
+	const models: string[] = [];
+	const modelCapabilities: Record<string, Partial<CapabilityFlags>> = {};
+	const modelStates: Record<string, ProbeModelStatus> = {};
+	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);
+		// The listing row wins on any field it fills. It is the endpoint the
+		// target chose to serve as canonical; the detail row only answers the
+		// questions the OpenAI schema cannot ask.
+		const caps = {
+			...(detailRow ? capabilitiesFromOpenAIModelEntry(detailRow) : {}),
+			...capabilitiesFromOpenAIModelEntry(row),
+		};
+		if (Object.keys(caps).length > 0) modelCapabilities[row.id] = caps;
+		const loadedContext = loadedContextFromEntry(row) ?? (detailRow ? loadedContextFromEntry(detailRow) : undefined);
+		const state =
+			modelStateFromOpenAIModelEntry(row) ??
+			(detailRow ? modelStateFromOpenAIModelEntry(detailRow) : undefined) ??
+			// A reported loaded context is itself the residency answer: nothing
+			// serves a window for a model it has not loaded.
+			(loadedContext !== undefined ? { state: "loaded" as const } : undefined);
+		if (state) modelStates[row.id] = loadedContext === undefined ? state : { ...state, contextLength: loadedContext };
+	}
+	return { models, modelCapabilities, modelStates };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function positiveNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function firstPositiveNumber(record: Record<string, unknown>, keys: ReadonlyArray<string>): number | undefined {
+	for (const key of keys) {
+		const value = positiveNumber(record[key]);
+		if (value !== undefined) return value;
+	}
+	return undefined;
+}
+
+/**
+ * `capabilities: ["tool_use"]`, the shape LM Studio uses. A listed capability
+ * is a claim of support; an absent one is silence, not a denial, so this
+ * returns true or undefined and never false.
+ */
+function capabilityListFlag(record: Record<string, unknown>, name: string): true | undefined {
+	const list = record.capabilities;
+	if (!Array.isArray(list)) return undefined;
+	return list.some((entry) => entry === name) ? true : undefined;
+}
+
+function booleanFromAny(record: Record<string, unknown>, keys: ReadonlyArray<string>): boolean | undefined {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "boolean") return value;
+	}
+	return undefined;
+}
+
+function nestedRecord(record: Record<string, unknown>, key: string): Record<string, unknown> | null {
+	const value = record[key];
+	return isRecord(value) ? value : null;
+}
+
+function firstString(record: Record<string, unknown> | null, keys: ReadonlyArray<string>): string | undefined {
+	if (!record) return undefined;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	}
+	return undefined;
+}
+
+function firstBoolean(record: Record<string, unknown> | null, keys: ReadonlyArray<string>): boolean | undefined {
+	if (!record) return undefined;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "boolean") return value;
+	}
+	return undefined;
+}
+
+function normalizeModelState(raw: string | undefined): ProbeModelStatus["state"] | undefined {
+	const value = raw
+		?.trim()
+		.toLowerCase()
+		.replace(/[\s_]+/g, "-");
+	if (!value) return undefined;
+	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 === "stopped") return "unloaded";
+	if (value === "failed" || value === "error" || value === "errored") return "failed";
+	if (value === "unknown") return "unknown";
+	return undefined;
+}
+
+function modelStateFromOpenAIModelEntry(row: Record<string, unknown>): ProbeModelStatus | undefined {
+	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 undefined;
+}
+
+/**
+ * The window a server has this model open at, as distinct from the window the
+ * model could support. Only the loaded keys count here: `max_context_length` is
+ * a fact about the weights, not about what is serving.
+ */
+function loadedContextFromEntry(row: Record<string, unknown>): number | undefined {
+	const reported = firstPositiveNumber(row, ["loaded_context_length", "loadedContextLength"]);
+	return reported === undefined ? undefined : Math.floor(reported);
+}
+
+function statusArgsFromEntry(row: Record<string, unknown>): string[] {
+	const status = nestedRecord(row, "status");
+	return argsFromStatus(status);
+}
+
+function capabilitiesFromOpenAIModelEntry(row: Record<string, unknown>): Partial<CapabilityFlags> {
+	const caps: Partial<CapabilityFlags> = {};
+	const meta = nestedRecord(row, "meta");
+	const flags = parseLlamaCppServerFlags(statusArgsFromEntry(row));
+	const contextWindow =
+		positiveNumber(flags.contextSize) ??
+		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"]) : undefined);
+	if (contextWindow !== undefined) 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 !== undefined) 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 !== undefined) caps.tools = tools;
+	const reasoning =
+		flags.reasoning ??
+		(flags.reasoningBudget !== undefined ? true : undefined) ??
+		booleanFromAny(row, ["reasoning", "thinking"]);
+	if (reasoning !== undefined) 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: OpenAIModelsResponse | undefined): Array<{ id: string; status?: unknown }> {
+	if (!Array.isArray(payload?.data)) return [];
+	const out: Array<{ id: string; status?: unknown }> = [];
+	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: string,
+	ctx: ProbeContext,
+): Promise<Array<{ id: string; status?: unknown }>> {
+	const opts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs } as const;
+	const result = await (ctx.signal
+		? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
+		: probeJson<OpenAIModelsResponse>(opts));
+	if (!result.ok) return [];
+	return modelEntries(result.data);
+}
+
+interface LlamaCppProps {
+	default_generation_settings?: { n_ctx?: unknown; n_predict?: unknown };
+	modalities?: { vision?: unknown };
+	build_info?: unknown;
+}
+
+export interface LlamaCppPropsEnrichment {
+	discoveredCapabilities?: Partial<CapabilityFlags>;
+	serverVersion?: string;
+}
+
+export interface LlamaCppServerFlags {
+	contextSize?: number;
+	maxTokens?: number;
+	flashAttention?: boolean;
+	cacheTypeK?: string;
+	cacheTypeV?: string;
+	jinja?: boolean;
+	reasoning?: boolean;
+	reasoningBudget?: number;
+	temperature?: number;
+	topP?: number;
+	topK?: number;
+	nGpuLayers?: number;
+	parallel?: number;
+	mmproj?: string;
+	chatTemplateKwargs?: string;
+}
+
+export interface LlamaCppStatusEnrichment {
+	discoveredCapabilities?: Partial<CapabilityFlags>;
+	modelId?: string;
+	serverFlags?: LlamaCppServerFlags;
+	notes?: string[];
+}
+
+function argsFromStatus(status: unknown): string[] {
+	if (!isRecord(status)) return [];
+	const args = status.args;
+	if (Array.isArray(args)) return args.filter((entry): entry is string => typeof entry === "string");
+	if (typeof args === "string") return args.trim().split(/\s+/).filter(Boolean);
+	return [];
+}
+
+function valueAfter(args: ReadonlyArray<string>, flag: string): string | undefined {
+	const index = args.indexOf(flag);
+	if (index < 0) return undefined;
+	const value = args[index + 1];
+	return value && !value.startsWith("--") ? value : undefined;
+}
+
+function numberFlag(args: ReadonlyArray<string>, flag: string): number | undefined {
+	const value = valueAfter(args, flag);
+	if (value === undefined) return undefined;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function booleanFlag(args: ReadonlyArray<string>, flag: string): boolean | undefined {
+	if (!args.includes(flag)) return undefined;
+	const value = valueAfter(args, flag);
+	if (value === undefined) 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 undefined;
+}
+
+function parseLlamaCppServerFlags(args: ReadonlyArray<string>): LlamaCppServerFlags {
+	const flags: LlamaCppServerFlags = {};
+	const ctxSize = numberFlag(args, "--ctx-size");
+	if (ctxSize !== undefined) flags.contextSize = ctxSize;
+	const maxTokens = numberFlag(args, "--n-predict");
+	if (maxTokens !== undefined) flags.maxTokens = maxTokens;
+	const flashAttention = booleanFlag(args, "--flash-attn");
+	if (flashAttention !== undefined) flags.flashAttention = flashAttention;
+	const jinja = booleanFlag(args, "--jinja");
+	if (jinja !== undefined) 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 !== undefined) flags.reasoningBudget = reasoningBudget;
+	const temperature = numberFlag(args, "--temperature");
+	if (temperature !== undefined) flags.temperature = temperature;
+	const topP = numberFlag(args, "--top-p");
+	if (topP !== undefined) flags.topP = topP;
+	const topK = numberFlag(args, "--top-k");
+	if (topK !== undefined) flags.topK = topK;
+	const nGpuLayers = numberFlag(args, "--n-gpu-layers");
+	if (nGpuLayers !== undefined) flags.nGpuLayers = nGpuLayers;
+	const parallel = numberFlag(args, "--parallel");
+	if (parallel !== undefined) flags.parallel = parallel;
+	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: ReadonlyArray<{ id: string; status?: unknown }>,
+	target: TargetDescriptor,
+): { id: string; status?: unknown } | null {
+	const expected = target.defaultModel?.trim();
+	if (expected) return entries.find((entry) => entry.id === expected) ?? null;
+	return entries[0] ?? null;
+}
+
+function statusNotes(id: string, status: unknown): string[] {
+	if (!isRecord(status)) return [];
+	const notes: string[] = [];
+	if (status.failed === true) notes.push(`llama.cpp router marks ${id} as failed`);
+	const state = typeof status.state === "string" ? status.state : undefined;
+	if (state === "loading") notes.push(`llama.cpp router reports ${id} is still loading`);
+	return notes;
+}
+
+export async function probeLlamaCppModelStatus(
+	base: string,
+	target: TargetDescriptor,
+	ctx: ProbeContext,
+): Promise<LlamaCppStatusEnrichment> {
+	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: Partial<CapabilityFlags> = {};
+	if (flags.contextSize !== undefined && flags.contextSize > 0) caps.contextWindow = flags.contextSize;
+	if (flags.maxTokens !== undefined && flags.maxTokens > 0) caps.maxTokens = flags.maxTokens;
+	if (flags.reasoning === true || flags.reasoningBudget !== undefined) caps.reasoning = true;
+	if (flags.mmproj) caps.vision = true;
+	if (flags.jinja === true) caps.tools = true;
+	const enrichment: LlamaCppStatusEnrichment = { modelId: selected.id, serverFlags: flags };
+	if (Object.keys(caps).length > 0) enrichment.discoveredCapabilities = caps;
+	const notes = statusNotes(selected.id, selected.status);
+	if (notes.length > 0) enrichment.notes = notes;
+	return enrichment;
+}
+
+/**
+ * llama.cpp serves a single fixed model per process. Compare the configured
+ * wire model id against `/v1/models` so a mismatch surfaces as a probe note
+ * instead of producing 404s or, worse, silent serves from the wrong weights.
+ * Returns null when the comparison is inconclusive (probe failed, no default
+ * model configured, server returned nothing).
+ */
+export async function detectModelMismatch(
+	base: string,
+	target: TargetDescriptor,
+	ctx: ProbeContext,
+): Promise<string | null> {
+	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`;
+}
+
+export async function probeLlamaCppProps(base: string, ctx: ProbeContext): Promise<LlamaCppPropsEnrichment> {
+	const opts = { url: `${base}/props`, timeoutMs: ctx.httpTimeoutMs } as const;
+	const result = await (ctx.signal
+		? probeJson<LlamaCppProps>({ ...opts, signal: ctx.signal })
+		: probeJson<LlamaCppProps>(opts));
+	if (!result.ok || !result.data) return {};
+	const data = result.data;
+	const enrichment: LlamaCppPropsEnrichment = {};
+	const caps: Partial<CapabilityFlags> = {};
+	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;
+}

package/src/domains/providers/runtimes/local-native/lemonade-anthropic.ts

@@ -0,0 +1,27 @@
+import { CLIO_MIN_CONTEXT_WINDOW, CLIO_MIN_MAX_OUTPUT_TOKENS } from "../../../../core/context-floor.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import { makeAnthropicCompatRuntime } from "../protocol/anthropic-compat.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	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,
+};
+
+export default makeAnthropicCompatRuntime({
+	id: "lemonade-anthropic",
+	displayName: "Lemonade (Anthropic-compat)",
+	provider: "lemonade",
+	auth: "api-key",
+	tier: "local-native",
+	defaultCapabilities,
+	hidden: true,
+});

package/src/domains/providers/runtimes/local-native/lemonade-openai.ts

@@ -0,0 +1,26 @@
+import { CLIO_MIN_CONTEXT_WINDOW, CLIO_MIN_MAX_OUTPUT_TOKENS } from "../../../../core/context-floor.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import { makeOpenAICompatRuntime } from "../protocol/openai-compat.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	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,
+};
+
+export default makeOpenAICompatRuntime({
+	id: "lemonade",
+	displayName: "Lemonade (OpenAI-compat)",
+	provider: "lemonade",
+	auth: "api-key",
+	tier: "local-native",
+	defaultCapabilities,
+});

package/src/domains/providers/runtimes/local-native/llamacpp-anthropic.ts

@@ -0,0 +1,88 @@
+import { CLIO_MIN_CONTEXT_WINDOW, CLIO_MIN_MAX_OUTPUT_TOKENS } from "../../../../core/context-floor.js";
+import type { Api, Model } from "../../../../engine/types.js";
+import { probeHttp, probeJson } from "../../probe/http.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { ProbeContext, ProbeResult, RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+import { stripTrailingSlash, synthLocalModel, withAsIs } from "../common/local-synth.js";
+import { detectModelMismatch, probeLlamaCppProps } from "../common/probe-helpers.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	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,
+};
+
+interface OpenAIModelsResponse {
+	data?: Array<{ id?: unknown }>;
+}
+
+function url(target: TargetDescriptor): string | null {
+	return target.url ? stripTrailingSlash(target.url) : null;
+}
+
+const llamacppAnthropicRuntime: RuntimeDescriptor = {
+	id: "llamacpp-anthropic",
+	displayName: "llama.cpp (Anthropic-compat)",
+	kind: "http",
+	tier: "local-native",
+	apiFamily: "anthropic-messages",
+	auth: "api-key",
+	defaultCapabilities,
+	hidden: true,
+	async probe(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
+		const base = url(target);
+		if (!base) return { ok: false, error: "target has no url" };
+		const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs } as const;
+		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" as const,
+			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: ProbeResult = { ...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: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {
+		const base = url(target);
+		if (!base) return [];
+		const opts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs } as const;
+		const result = await (ctx.signal
+			? probeJson<OpenAIModelsResponse>({ ...opts, signal: ctx.signal })
+			: probeJson<OpenAIModelsResponse>(opts));
+		if (!result.ok || !result.data?.data) return [];
+		return result.data.data
+			.map((row) => (typeof row?.id === "string" ? row.id : null))
+			.filter((id): id is string => id !== null);
+	},
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthLocalModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			apiFamily: "anthropic-messages",
+			provider: "llamacpp",
+			baseUrlForTarget: withAsIs,
+		});
+	},
+};
+
+export default llamacppAnthropicRuntime;