@iowarp/clio-coder 0.4.2 → 0.4.3

package/src/domains/providers/runtimes/antigravity/antigravity-code.ts

@@ -1,78 +1,258 @@
+import { boundedExternalDiagnostic } from "../../../../core/external-diagnostic.js";
+import { runCommandVector, type SafeCommandResult } from "../../../../core/safe-exec.js";
 import type { Api, Model } from "../../../../engine/types.js";
 
 import { synthesizeCatalogBackedModel } from "../../catalog.js";
 import type { CapabilityFlags } from "../../types/capability-flags.js";
 import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
-import type { RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { ProbeContext, ProbeResult, RuntimeDescriptor } from "../../types/runtime-descriptor.js";
 import type { TargetDescriptor } from "../../types/target-descriptor.js";
 
 /**
- * Antigravity CLI (`agy`) subscription runtime.
+ * Antigravity CLI (`agy`) external delegation runtime.
  *
- * A subprocess worker runtime that drives the local `agy --print`, the same
- * shape as the `claude-code` runtime: Clio spawns the CLI, streams its output,
- * and maps Clio autonomy levels onto the CLI's permission flags. `agy` brings
- * Google's Antigravity agent harness (Gemini 3.x and hosted Claude/GPT-OSS
- * models, up to ~1M tokens of context) to the Clio worker fleet.
- *
- * `agy --print` prints plain text (there is no structured event stream), so the
- * worker runner cannot mediate individual agy tool calls the way the Claude SDK
- * runner does. Permission gating is coarse: `--mode plan --sandbox` for
- * read-only runs and `--dangerously-skip-permissions` only under `full-auto`
- * plus the explicit `CLIO_CODER_ALLOW_EXTERNAL_FULL_ACCESS=1` environment gate.
- * agy's own `settings.json` still governs modes that Clio does not explicitly
- * constrain.
+ * This is deliberately a dispatch-only subprocess, not a Gemini inference
+ * provider. The installed official CLI owns authentication, its agent loop,
+ * tools, network access, and model access. Clio supplies one bounded work order
+ * and translates the documented structured result into a worker result.
  */
 
 export const ANTIGRAVITY_AUTH_NOTICE =
-	"Uses your existing Antigravity (`agy`) login. Clio stores no Antigravity credentials. " +
-	"agy runs its own agent harness as a subprocess; Clio maps autonomy levels onto its CLI flags " +
-	"but cannot mediate individual agy tool calls.";
+	"Experimental local delegation through your installed Antigravity (`agy`) CLI. Clio neither signs in nor stores " +
+	"or inspects Antigravity credentials. Run `agy` yourself and complete sign-in before probing this target.";
 
-// Exact model strings accepted by `agy --model` (from `agy models`). The High
-// Flash tier leads: it is the fast, large-context default.
+// Hints only until an account returns a live catalog. They are never used to
+// validate a model after a successful live probe.
 export const ANTIGRAVITY_MODELS: ReadonlyArray<string> = [
-	"Gemini 3.5 Flash (High)",
-	"Gemini 3.5 Flash (Medium)",
-	"Gemini 3.5 Flash (Low)",
-	"Gemini 3.1 Pro (High)",
-	"Gemini 3.1 Pro (Low)",
-	"Claude Sonnet 4.6 (Thinking)",
-	"Claude Opus 4.6 (Thinking)",
-	"GPT-OSS 120B (Medium)",
+	"gemini-3.8-flash-high",
+	"gemini-3.8-flash-medium",
+	"gemini-3.8-flash-low",
+	"gemini-3.1-pro-high",
+	"gemini-3.1-pro-low",
 ];
 
+/** Typed Clio capabilities only. Antigravity's own opaque tools are declared separately. */
 export const antigravityCapabilities: CapabilityFlags = {
 	chat: true,
-	tools: true,
-	toolCallFormat: "openai",
-	reasoning: true,
-	vision: true,
+	tools: false,
+	reasoning: false,
+	vision: false,
 	audio: false,
 	embeddings: false,
 	rerank: false,
 	fim: false,
-	contextWindow: 1_000_000,
-	maxTokens: 8192,
+	contextWindow: 0,
+	maxTokens: 0,
 };
 
+export const ANTIGRAVITY_MAX_CATALOG_BYTES = 1024 * 1024;
+export const ANTIGRAVITY_MAX_DISCOVERED_MODELS = 4096;
+const MAX_MODEL_ID_CHARS = 1024;
+const MAX_MODEL_LABEL_CHARS = 1024;
+
+type AntigravityProbeFailureKind = NonNullable<ProbeResult["failureKind"]>;
+
+class AntigravityCatalogError extends Error {
+	readonly kind: AntigravityProbeFailureKind;
+
+	constructor(kind: AntigravityProbeFailureKind, message: string) {
+		super(message);
+		this.name = "AntigravityCatalogError";
+		this.kind = kind;
+	}
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+export interface AntigravityModelCatalog {
+	models: string[];
+	labels: Record<string, string>;
+}
+
+/** Decode the machine-readable catalog emitted by `agy --output-format json models`. */
+export function parseAntigravityModelCatalogDetails(output: string): AntigravityModelCatalog {
+	let decoded: unknown;
+	try {
+		decoded = JSON.parse(output);
+	} catch {
+		throw new AntigravityCatalogError(
+			"unsupported-feature",
+			"agy returned an unreadable model catalog; update the Antigravity CLI and retry",
+		);
+	}
+	const envelope = record(decoded);
+	const command = record(envelope?.command);
+	const data = record(command?.data);
+	if (envelope?.status !== "SUCCESS") {
+		const detail = boundedExternalDiagnostic(
+			typeof envelope?.error === "string"
+				? envelope.error
+				: typeof command?.error === "string"
+					? command.error
+					: "agy could not list models",
+		);
+		const kind = classifyAntigravityDiagnostic(detail);
+		throw new AntigravityCatalogError(kind, antigravityProbeMessage(kind, detail));
+	}
+	if (command?.name !== "models" || !Array.isArray(data?.models)) {
+		throw new AntigravityCatalogError(
+			"unsupported-feature",
+			"agy returned an unsupported model catalog; update the Antigravity CLI and retry",
+		);
+	}
+	if (data.models.length === 0) {
+		throw new AntigravityCatalogError(
+			"catalog-unavailable",
+			"agy returned no available models; run `agy` locally and verify the signed-in account has model access",
+		);
+	}
+	if (data.models.length > ANTIGRAVITY_MAX_DISCOVERED_MODELS) {
+		throw new AntigravityCatalogError(
+			"catalog-unavailable",
+			`agy returned more than ${ANTIGRAVITY_MAX_DISCOVERED_MODELS} models; the authoritative catalog was refused rather than truncated`,
+		);
+	}
+
+	const models: string[] = [];
+	const labels: Record<string, string> = {};
+	const seen = new Set<string>();
+	for (const value of data.models) {
+		const model = record(value);
+		const id = typeof model?.id === "string" ? model.id.trim() : "";
+		const label = typeof model?.label === "string" ? model.label.trim() : "";
+		if (id.length === 0 || id.length > MAX_MODEL_ID_CHARS || /[\r\n\0]/u.test(id)) {
+			throw new AntigravityCatalogError("catalog-unavailable", "agy returned an invalid model identifier");
+		}
+		if (label.length === 0 || label.length > MAX_MODEL_LABEL_CHARS || /[\r\n\0]/u.test(label)) {
+			throw new AntigravityCatalogError("catalog-unavailable", `agy returned an invalid label for model '${id}'`);
+		}
+		if (seen.has(id)) {
+			if (labels[id] !== label) {
+				throw new AntigravityCatalogError(
+					"catalog-unavailable",
+					`agy returned conflicting labels for duplicate model '${id}'`,
+				);
+			}
+			continue;
+		}
+		seen.add(id);
+		models.push(id);
+		labels[id] = label;
+	}
+	return { models, labels };
+}
+
+function classifyAntigravityDiagnostic(detail: string): AntigravityProbeFailureKind {
+	if (/(?:enoent|not found|cannot find|could not start|spawn .*agy)/iu.test(detail)) return "missing";
+	if (/(?:sign[ -]?in|log[ -]?in|unauthori[sz]ed|authenticat|credential|account.*required)/iu.test(detail)) {
+		return "authentication";
+	}
+	if (
+		/(?:unknown|unsupported|unrecognized|invalid) (?:option|argument|command)|output-format|models command/iu.test(detail)
+	) {
+		return "unsupported-feature";
+	}
+	return "generic";
+}
+
+function antigravityProbeMessage(kind: AntigravityProbeFailureKind, detail: string): string {
+	const safeDetail = boundedExternalDiagnostic(detail || "no diagnostic was provided");
+	switch (kind) {
+		case "missing":
+			return "Antigravity CLI is not installed or `agy` is not on PATH";
+		case "authentication":
+			return `Antigravity sign-in is required; run \`agy\` yourself and complete sign-in (${safeDetail})`;
+		case "unsupported-feature":
+			return `the installed Antigravity CLI does not expose the required structured model catalog; update \`agy\` (${safeDetail})`;
+		case "catalog-unavailable":
+			return safeDetail;
+		case "cancelled":
+			return "Antigravity model discovery was cancelled";
+		default:
+			return `Antigravity model discovery failed: ${safeDetail}`;
+	}
+}
+
+export async function probeAntigravityModelCatalog(
+	ctx: ProbeContext,
+	runner: typeof runCommandVector = runCommandVector,
+): Promise<ProbeResult> {
+	const result: SafeCommandResult = await runner("agy", ["--output-format", "json", "models"], {
+		cwd: process.cwd(),
+		workspaceRoot: process.cwd(),
+		timeoutMs: Math.max(1, ctx.httpTimeoutMs),
+		maxOutputBytes: ANTIGRAVITY_MAX_CATALOG_BYTES,
+		...(ctx.signal ? { signal: ctx.signal } : {}),
+	});
+	if (result.aborted || result.timedOut) {
+		return {
+			ok: false,
+			latencyMs: result.durationMs,
+			failureKind: "cancelled",
+			error: antigravityProbeMessage("cancelled", ""),
+		};
+	}
+	if (result.outputCapped) {
+		return {
+			ok: false,
+			latencyMs: result.durationMs,
+			failureKind: "catalog-unavailable",
+			error: `agy model catalog exceeded ${ANTIGRAVITY_MAX_CATALOG_BYTES} bytes`,
+		};
+	}
+	if (result.exitCode !== 0) {
+		const detail = boundedExternalDiagnostic(result.stderr || result.stdout || `agy exited ${String(result.exitCode)}`);
+		const kind = classifyAntigravityDiagnostic(detail);
+		return { ok: false, latencyMs: result.durationMs, failureKind: kind, error: antigravityProbeMessage(kind, detail) };
+	}
+	try {
+		const catalog = parseAntigravityModelCatalogDetails(result.stdout);
+		return {
+			ok: true,
+			latencyMs: result.durationMs,
+			models: catalog.models,
+			modelLabels: catalog.labels,
+		};
+	} catch (cause) {
+		const kind = cause instanceof AntigravityCatalogError ? cause.kind : "generic";
+		const detail = cause instanceof Error ? cause.message : String(cause);
+		return { ok: false, latencyMs: result.durationMs, failureKind: kind, error: boundedExternalDiagnostic(detail) };
+	}
+}
+
 const antigravityCodeRuntime: RuntimeDescriptor = {
 	id: "antigravity-code",
-	displayName: "Antigravity CLI",
+	displayName: "Antigravity CLI — experimental local delegation",
 	kind: "subprocess",
 	tier: "subscription",
-	// Reuses the existing `google-generative-ai` api family: the worker branches
-	// to its own runner before any pi-ai inference, so this only needs to be a
-	// valid, google-backed family. The runner is selected by runtime id, and the
-	// plain-text parser is named by `outputParser`.
-	apiFamily: "google-generative-ai",
+	apiFamily: "external-agent-subprocess",
 	auth: "none",
 	authNotice: ANTIGRAVITY_AUTH_NOTICE,
 	knownModels: [...ANTIGRAVITY_MODELS],
 	binaryName: "agy",
-	headlessCommand: "agy --print",
-	outputParser: "antigravity-print-text",
+	headlessCommand: "agy --input-format stream-json --output-format stream-json",
+	outputParser: "antigravity-stream-json",
 	defaultCapabilities: antigravityCapabilities,
+	externalAgentLoop: {
+		tools: "externally-governed-unobserved",
+		network: "externally-governed-unobserved",
+		budget: "external-one-shot",
+		generatingRetry: "forbidden",
+		modelCatalog: "live-authoritative",
+	},
+	async probe(_target: TargetDescriptor, ctx: ProbeContext) {
+		try {
+			return await probeAntigravityModelCatalog(ctx);
+		} catch (cause) {
+			const detail = boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
+			const kind = classifyAntigravityDiagnostic(detail);
+			return { ok: false, failureKind: kind, error: antigravityProbeMessage(kind, detail) };
+		}
+	},
 	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
 		return synthesizeCatalogBackedModel({
 			target,
@@ -80,9 +260,9 @@ const antigravityCodeRuntime: RuntimeDescriptor = {
 			kb,
 			defaultCapabilities: antigravityCapabilities,
 			runtimeId: "antigravity-code",
-			api: "google-generative-ai",
-			provider: "google",
-			defaultBaseUrl: "antigravity://local",
+			api: "external-agent-subprocess",
+			provider: "antigravity",
+			defaultBaseUrl: "external-agent://antigravity/local",
 		});
 	},
 };

package/src/domains/providers/runtimes/common/lmstudio-http.ts

@@ -300,9 +300,13 @@ export function lmStudioReasoningLevels(options: ReadonlyArray<string> | undefin
 export function lmStudioReasoningEffort(
 	level: ThinkingLevel,
 	options?: ReadonlyArray<string>,
-): "none" | "low" | "medium" | "high" {
+): "none" | "low" | "medium" | "high" | undefined {
+	// `allowed_options` describes the model's binary setting, but LM Studio's
+	// OpenAI-compatible request schema still accepts only effort-level values.
+	// Omit an active override for binary/default-on models; sending `low` works
+	// only through a warning and sending the advertised literal `on` is a 400.
+	if (options?.includes("on") && options.includes("off")) return level === "off" ? "none" : undefined;
 	if (level === "off") return "none";
-	if (options?.includes("on") && !options.includes("medium") && !options.includes("high")) return "low";
 	if (level === "medium" && options?.includes("medium") !== false) return "medium";
 	if ((level === "high" || level === "xhigh" || level === "max") && options?.includes("high") !== false) return "high";
 	return "low";

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

@@ -24,6 +24,7 @@ export interface ClioLocalModelMetadata {
 		quirks?: LocalModelQuirks;
 		chatTemplateKwargsUnsupported?: boolean;
 		lmstudio?: TargetDescriptor["lmstudio"];
+		litellm?: TargetDescriptor["litellm"];
 	};
 }
 
@@ -109,6 +110,7 @@ export function synthLocalModel(input: LocalSynthesisInput): Model<Api> {
 			...(kb?.entry.family ? { family: kb.entry.family } : {}),
 			...(quirks ? { quirks } : {}),
 			...(target.lmstudio ? { lmstudio: target.lmstudio } : {}),
+			...(target.litellm ? { litellm: target.litellm } : {}),
 		},
 	};
 	if (headers) model.headers = headers;

package/src/domains/providers/runtimes/protocol/litellm.ts

@@ -4,11 +4,11 @@
  * This is a separate runtime from `openai-compat` rather than a target flag on
  * it, because a gateway answers two questions the generic protocol cannot.
  *
- * First, capability discovery. A gateway publishes semantic aliases: the client
- * asks for `code` and the proxy decides that means `katcoder2.5-35b-moe` on one
- * particular host. LiteLLM's `/v1/models` is the plain OpenAI listing, so every
- * row flattens to a bare id and the context window, tool support, and modality
- * of the model actually behind the alias are all erased. Reached over
+ * First, capability discovery. A gateway may publish aliases or truthful
+ * physical names such as `dynamo/qwen3.8-27b`. LiteLLM's `/v1/models` is the
+ * plain OpenAI listing, so every row flattens to a bare id and the context
+ * window, tool support, and modality of the model behind it are all erased.
+ * Reached over
  * `openai-compat`, a 262k tool-calling coder is indistinguishable from a 4k
  * chat toy, and Clio plans the session against its own assumed floor. LiteLLM
  * publishes the real numbers on `/v1/model/info` instead, which is what this
@@ -26,7 +26,8 @@
  * and rejected HTTP 400 by LM Studio, and the same prompt with no
  * `response_format` returned plain prose. `drop_params: true` did not strip
  * either spelling. The standard `json_schema` dialect is therefore the one that
- * holds across every upstream, and it is what this runtime declares.
+ * holds across every measured upstream, and a gateway must publish that fact
+ * explicitly per route in `model_info` before Clio relies on it.
  */
 
 import { CLIO_MIN_CONTEXT_WINDOW, CLIO_MIN_MAX_OUTPUT_TOKENS } from "../../../../core/context-floor.js";
@@ -55,7 +56,7 @@ const defaultCapabilities: CapabilityFlags = {
 	embeddings: false,
 	rerank: false,
 	fim: false,
-	structuredOutputs: "json-schema",
+	structuredOutputs: "none",
 	contextWindow: CLIO_MIN_CONTEXT_WINDOW,
 	maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS,
 };
@@ -106,8 +107,11 @@ function boolean(value: unknown): boolean | undefined {
  * so the caller can tell "the gateway says this model has no vision" apart from
  * "the gateway did not say", and merge accordingly.
  */
-function capabilitiesFromLiteLLMModelInfo(info: Record<string, unknown>): Partial<CapabilityFlags> {
+export function capabilitiesFromLiteLLMModelInfo(info: Record<string, unknown>): Partial<CapabilityFlags> {
 	const caps: Partial<CapabilityFlags> = {};
+	// This is a deployment declaration, never inferred from a URL, port or alias.
+	if (info.runtime === "lm-studio") caps.thinkingControlRuntime = "lmstudio";
+	else if (info.runtime === "llama.cpp") caps.thinkingControlRuntime = "llamacpp";
 	const contextWindow = positiveInteger(info.max_input_tokens) ?? positiveInteger(info.max_tokens);
 	if (contextWindow !== undefined) caps.contextWindow = contextWindow;
 	const maxTokens = positiveInteger(info.max_output_tokens);
@@ -132,20 +136,77 @@ function capabilitiesFromLiteLLMModelInfo(info: Record<string, unknown>): Partia
 		caps.rerank = true;
 	}
 	if (info.mode === "chat") caps.chat = true;
-	// Measured, not inferred: see the module header.
-	if (boolean(info.supports_response_schema) === true) caps.structuredOutputs = "json-schema";
+	// Measured, not inferred: see the module header. An explicit false must
+	// override this runtime's measured default for an upstream that cannot
+	// preserve the schema contract.
+	const responseSchema = boolean(info.supports_response_schema);
+	if (responseSchema !== undefined) caps.structuredOutputs = responseSchema ? "json-schema" : "none";
 	return caps;
 }
 
+const BOOLEAN_CAPABILITIES = [
+	"chat",
+	"tools",
+	"reasoning",
+	"vision",
+	"audio",
+	"embeddings",
+	"rerank",
+	"fim",
+] as const satisfies ReadonlyArray<keyof CapabilityFlags>;
+
+/**
+ * One alias may load-balance across heterogeneous deployments. Clio can only
+ * promise what every possible route supports: numerical limits take the
+ * smallest fully-published value, booleans require unanimous publication, and
+ * one explicit false defeats a true. Missing data never becomes a capability.
+ */
+export function aggregateLiteLLMCapabilities(rows: ReadonlyArray<Partial<CapabilityFlags>>): Partial<CapabilityFlags> {
+	if (rows.length === 0) return {};
+	const aggregate: Partial<CapabilityFlags> = {};
+	for (const key of ["contextWindow", "maxTokens"] as const) {
+		const values = rows.map((row) => row[key]);
+		if (values.every((value): value is number => typeof value === "number")) {
+			aggregate[key] = Math.min(...values);
+		}
+	}
+	for (const key of BOOLEAN_CAPABILITIES) {
+		const values = rows.map((row) => row[key]);
+		if (values.some((value) => value === false)) aggregate[key] = false;
+		else if (values.every((value) => value === true)) aggregate[key] = true;
+	}
+	const controlRuntime = rows[0]?.thinkingControlRuntime;
+	if (controlRuntime !== undefined && rows.every((row) => row.thinkingControlRuntime === controlRuntime)) {
+		aggregate.thinkingControlRuntime = controlRuntime;
+	}
+	const structuredOutputs = rows.map((row) => row.structuredOutputs);
+	if (structuredOutputs.some((value) => value === "none")) aggregate.structuredOutputs = "none";
+	else if (structuredOutputs.every((value) => value === "json-schema")) aggregate.structuredOutputs = "json-schema";
+	return aggregate;
+}
+
 interface LiteLLMCatalog {
 	models: string[];
 	modelCapabilities: Record<string, Partial<CapabilityFlags>>;
 	modelStates: Record<string, ProbeModelStatus>;
 	/** Physical deployment behind each alias, for display. */
-	deployments: Record<string, { model: string; apiBase?: string }>;
+	deployments: Record<string, Array<{ model: string; apiBase?: string }>>;
+	/** Whether the empty catalog is specifically because the gateway rejected the key. */
+	authFailed: boolean;
 }
 
-const EMPTY_CATALOG: LiteLLMCatalog = { models: [], modelCapabilities: {}, modelStates: {}, deployments: {} };
+const EMPTY_CATALOG: LiteLLMCatalog = {
+	models: [],
+	modelCapabilities: {},
+	modelStates: {},
+	deployments: {},
+	authFailed: false,
+};
+
+/** Whether a failed probe leg failed specifically on the credential, not on reachability. */
+function isAuthError(leg: { ok: boolean; error?: string }): boolean {
+	return !leg.ok && /^HTTP 40[13]\b/u.test(leg.error ?? "");
+}
 
 /**
  * Read the catalog from `/v1/model/info`, falling back to `/v1/models`.
@@ -163,37 +224,50 @@ async function fetchCatalog(base: string, ctx: ProbeContext, headers: Record<str
 		: probeJson<LiteLLMModelInfoResponse>(detailOpts));
 
 	if (detail.ok && Array.isArray(detail.data?.data)) {
-		const catalog: LiteLLMCatalog = { models: [], modelCapabilities: {}, modelStates: {}, deployments: {} };
+		const catalog: LiteLLMCatalog = {
+			models: [],
+			modelCapabilities: {},
+			modelStates: {},
+			deployments: {},
+			authFailed: false,
+		};
+		const capabilityRows: Record<string, Array<Partial<CapabilityFlags>>> = {};
 		for (const row of detail.data.data) {
 			if (typeof row?.model_name !== "string" || row.model_name.length === 0) continue;
 			const alias = row.model_name;
-			// One alias can carry several deployments. They share a name and Clio
-			// addresses them as one model, so the first row establishes the entry
-			// and later rows for the same alias are the load-balancing pool behind
-			// it rather than separate models.
-			if (catalog.deployments[alias] !== undefined) continue;
-			catalog.models.push(alias);
+			if (catalog.deployments[alias] === undefined) {
+				catalog.models.push(alias);
+				catalog.deployments[alias] = [];
+				capabilityRows[alias] = [];
+			}
 			const caps = row.model_info ? capabilitiesFromLiteLLMModelInfo(row.model_info) : {};
-			if (Object.keys(caps).length > 0) catalog.modelCapabilities[alias] = caps;
+			capabilityRows[alias]?.push(caps);
 			const upstream = row.litellm_params?.model;
 			const apiBase = row.litellm_params?.api_base;
-			catalog.deployments[alias] = {
+			catalog.deployments[alias]?.push({
 				model: typeof upstream === "string" ? upstream : alias,
 				...(typeof apiBase === "string" ? { apiBase } : {}),
-			};
+			});
+		}
+		for (const alias of catalog.models) {
+			const caps = aggregateLiteLLMCapabilities(capabilityRows[alias] ?? []);
+			if (Object.keys(caps).length > 0) catalog.modelCapabilities[alias] = caps;
 		}
 		if (catalog.models.length > 0) return catalog;
 	}
+	const detailAuthFailed = isAuthError(detail);
 
 	const listOpts = { url: `${base}/v1/models`, timeoutMs: ctx.httpTimeoutMs, headers } as const;
 	const list = await (ctx.signal
 		? probeJson<LiteLLMModelsResponse>({ ...listOpts, signal: ctx.signal })
 		: probeJson<LiteLLMModelsResponse>(listOpts));
-	if (!list.ok || !Array.isArray(list.data?.data)) return EMPTY_CATALOG;
+	if (!list.ok || !Array.isArray(list.data?.data)) {
+		return { ...EMPTY_CATALOG, authFailed: detailAuthFailed || isAuthError(list) };
+	}
 	const models = list.data.data
 		.map((row) => (typeof row?.id === "string" ? row.id : null))
 		.filter((id): id is string => id !== null && id.length > 0);
-	return { models, modelCapabilities: {}, modelStates: {}, deployments: {} };
+	return { models, modelCapabilities: {}, modelStates: {}, deployments: {}, authFailed: false };
 }
 
 const litellmRuntime: RuntimeDescriptor = {
@@ -226,8 +300,11 @@ const litellmRuntime: RuntimeDescriptor = {
 		if (catalog.models.length === 0) {
 			const result: ProbeResult = {
 				ok: false,
-				error: "gateway is live but served no model catalog; check the target's API key",
+				error: catalog.authFailed
+					? "gateway rejected the key"
+					: "gateway is live but served no model catalog; check the target's API key",
 			};
+			if (catalog.authFailed) result.authFailed = true;
 			if (live.latencyMs !== undefined) result.latencyMs = live.latencyMs;
 			return result;
 		}
@@ -248,10 +325,23 @@ const litellmRuntime: RuntimeDescriptor = {
 		if (configured && !catalog.models.includes(configured)) {
 			notes.push(`configured model '${configured}' is not in the gateway catalog`);
 		}
-		// Naming the physical model behind each alias is the difference between a
-		// catalog an operator can audit and a list of words.
-		const routed = Object.entries(catalog.deployments)
-			.map(([alias, deployment]) => `${alias}=${deployment.model}`)
+		// A node/model catalog already names placement. Summarize those one-to-one
+		// routes instead of flooding target diagnostics with dozens of tautologies;
+		// retain the explicit mapping for genuine aliases and multi-deployments.
+		const routeEntries = Object.entries(catalog.deployments);
+		const physical = routeEntries.filter(([alias, deployments]) => {
+			const slash = alias.indexOf("/");
+			if (slash <= 0 || deployments.length !== 1) return false;
+			const upstream = deployments[0]?.model.replace(/^openai\//u, "");
+			return upstream === alias.slice(slash + 1);
+		});
+		if (physical.length > 0) notes.push(`physical routes: ${physical.length} node/model names map one-to-one`);
+		const routed = routeEntries
+			.filter(([alias]) => !physical.some(([physicalAlias]) => physicalAlias === alias))
+			.map(([alias, deployments]) => {
+				const models = [...new Set(deployments.map((deployment) => deployment.model))];
+				return `${alias}=${models.join("|")}`;
+			})
 			.sort();
 		if (routed.length > 0) notes.push(`routes: ${routed.join(", ")}`);
 		if (notes.length > 0) result.notes = notes;

package/src/domains/providers/support.ts

@@ -5,7 +5,7 @@ import { getRuntimeRegistry } from "./registry.js";
 import type { RuntimeDescriptor } from "./types/runtime-descriptor.js";
 import type { TargetDescriptor } from "./types/target-descriptor.js";
 
-export type ProviderSupportGroup = "featured" | "cloud-api" | "subscription" | "local-http";
+export type ProviderSupportGroup = "featured" | "external-worker" | "cloud-api" | "subscription" | "local-http";
 
 /**
  * Where a runtime's model ids come from, which decides whether their order
@@ -44,6 +44,7 @@ const SUMMARY_BY_RUNTIME_ID: Readonly<Record<string, string>> = {
 	alcf: "ALCF inference gateway (Sophia/Metis) via Globus",
 	anthropic: "Anthropic API",
 	"anthropic-max": "Claude Pro/Max subscription via Anthropic OAuth",
+	"antigravity-code": "Experimental local delegation via the installed Antigravity CLI",
 	bedrock: "Amazon Bedrock",
 	"claude-code": "Claude Code subscription via installed claude CLI",
 	"claude-sdk": "Claude Code subscription via Claude Agent SDK",
@@ -59,19 +60,21 @@ const SUMMARY_BY_RUNTIME_ID: Readonly<Record<string, string>> = {
 	llamacpp: "llama.cpp server (auto-detect surface)",
 	"anthropic-compat": "Generic Anthropic-compatible REST",
 	"openai-compat": "Generic OpenAI-compatible REST",
-	litellm: "LiteLLM gateway with per-alias capability discovery and routed-model attribution",
+	litellm: "LiteLLM gateway with per-route capability discovery and physical-model attribution",
 };
 
 function groupPriority(group: ProviderSupportGroup): number {
 	switch (group) {
 		case "featured":
 			return 0;
-		case "subscription":
+		case "external-worker":
 			return 1;
-		case "cloud-api":
+		case "subscription":
 			return 2;
-		case "local-http":
+		case "cloud-api":
 			return 3;
+		case "local-http":
+			return 4;
 	}
 }
 
@@ -79,6 +82,8 @@ export function supportGroupLabel(group: ProviderSupportGroup): string {
 	switch (group) {
 		case "featured":
 			return "Featured";
+		case "external-worker":
+			return "External delegation";
 		case "subscription":
 			return "Subscriptions";
 		case "cloud-api":
@@ -90,6 +95,7 @@ export function supportGroupLabel(group: ProviderSupportGroup): string {
 
 function classifyGroup(runtime: RuntimeDescriptor): ProviderSupportGroup {
 	if (runtime.id === "openai-codex") return "featured";
+	if (runtime.externalAgentLoop !== undefined) return "external-worker";
 	if (runtime.id === "alcf") return "cloud-api";
 	if (runtime.auth === "oauth" || runtime.auth === "claude-cli") return "subscription";
 	if (catalogProviderForRuntime(runtime.id) || (runtime.auth === "api-key" && !runtime.probe)) {