@iowarp/clio-coder 0.3.0 → 0.3.1

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

@@ -0,0 +1,90 @@
+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 { TargetDescriptor } from "../../types/target-descriptor.js";
+
+/**
+ * Antigravity CLI (`agy`) subscription 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.
+ */
+
+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.";
+
+// Exact model strings accepted by `agy --model` (from `agy models`). The High
+// Flash tier leads: it is the fast, large-context default.
+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)",
+];
+
+export const antigravityCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "openai",
+	reasoning: true,
+	vision: true,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 1_000_000,
+	maxTokens: 8192,
+};
+
+const antigravityCodeRuntime: RuntimeDescriptor = {
+	id: "antigravity-code",
+	displayName: "Antigravity CLI",
+	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",
+	auth: "none",
+	authNotice: ANTIGRAVITY_AUTH_NOTICE,
+	knownModels: [...ANTIGRAVITY_MODELS],
+	binaryName: "agy",
+	headlessCommand: "agy --print",
+	outputParser: "antigravity-print-text",
+	defaultCapabilities: antigravityCapabilities,
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthesizeCatalogBackedModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities: antigravityCapabilities,
+			runtimeId: "antigravity-code",
+			api: "google-generative-ai",
+			provider: "google",
+			defaultBaseUrl: "antigravity://local",
+		});
+	},
+};
+
+export default antigravityCodeRuntime;

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

@@ -0,0 +1,78 @@
+/**
+ * Registers every runtime descriptor that ships in-tree with the given
+ * registry. Safe to call repeatedly: descriptor ids that are already
+ * registered are skipped, so tests and boot paths that poke pieces of the
+ * registry before the providers domain starts won't double-register.
+ *
+ * Third-party runtimes from ~/.config/clio-coder/runtimes/ or npm plugins are loaded
+ * separately by `loadPluginRuntimes` in `./plugins.ts`.
+ */
+
+import type { RuntimeRegistry } from "../registry.js";
+import type { RuntimeDescriptor } from "../types/runtime-descriptor.js";
+import antigravityCode from "./antigravity/antigravity-code.js";
+import claudeCode from "./claude/claude-code.js";
+import claudeSdk from "./claude/claude-sdk.js";
+import alcf from "./cloud/alcf.js";
+import anthropic from "./cloud/anthropic.js";
+import anthropicMax from "./cloud/anthropic-max.js";
+import bedrock from "./cloud/bedrock.js";
+import deepseek from "./cloud/deepseek.js";
+import google from "./cloud/google.js";
+import groq from "./cloud/groq.js";
+import mistral from "./cloud/mistral.js";
+import openai from "./cloud/openai.js";
+import openaiCodex from "./cloud/openai-codex.js";
+import openrouter from "./cloud/openrouter.js";
+import lemonadeAnthropic from "./local-native/lemonade-anthropic.js";
+import lemonadeOpenai from "./local-native/lemonade-openai.js";
+import llamacpp from "./local-native/llamacpp.js";
+import llamacppAnthropic from "./local-native/llamacpp-anthropic.js";
+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 lmstudioNative from "./local-native/lmstudio-native.js";
+import ollamaNative from "./local-native/ollama-native.js";
+import sglang from "./local-native/sglang.js";
+import vllm from "./local-native/vllm.js";
+import anthropicCompat from "./protocol/anthropic-compat.js";
+import openaiCompat from "./protocol/openai-compat.js";
+
+const BUILTIN_RUNTIMES: ReadonlyArray<RuntimeDescriptor> = [
+	alcf,
+	anthropic,
+	anthropicMax,
+	bedrock,
+	deepseek,
+	google,
+	groq,
+	mistral,
+	openai,
+	openaiCodex,
+	openrouter,
+	lemonadeAnthropic,
+	lemonadeOpenai,
+	llamacpp,
+	llamacppAnthropic,
+	llamacppCompletion,
+	llamacppEmbed,
+	llamacppRerank,
+	lmstudioNative,
+	ollamaNative,
+	anthropicCompat,
+	openaiCompat,
+	sglang,
+	vllm,
+	claudeCode,
+	claudeSdk,
+	antigravityCode,
+];
+
+export function registerBuiltinRuntimes(registry: RuntimeRegistry): void {
+	for (const desc of BUILTIN_RUNTIMES) {
+		if (registry.get(desc.id) !== null) continue;
+		registry.register(desc);
+	}
+}
+
+export { BUILTIN_RUNTIMES };

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

@@ -0,0 +1,38 @@
+import type { Api, Model } from "../../../../engine/types.js";
+
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+import {
+	CLAUDE_CODE_AUTH_NOTICE,
+	CLAUDE_CODE_MODELS,
+	claudeCodeCapabilities,
+	synthesizeClaudeDelegatedModel,
+} from "./common.js";
+
+const claudeCodeRuntime: RuntimeDescriptor = {
+	id: "claude-code",
+	displayName: "Claude Code CLI",
+	kind: "subprocess",
+	tier: "subscription",
+	apiFamily: "claude-code-subprocess",
+	auth: "claude-cli",
+	authNotice: CLAUDE_CODE_AUTH_NOTICE,
+	knownModels: [...CLAUDE_CODE_MODELS],
+	binaryName: "claude",
+	headlessCommand: "claude -p --output-format stream-json",
+	outputParser: "claude-code-stream-json",
+	defaultCapabilities: claudeCodeCapabilities,
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthesizeClaudeDelegatedModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities: claudeCodeCapabilities,
+			runtimeId: "claude-code",
+			apiFamily: "claude-code-subprocess",
+		});
+	},
+};
+
+export default claudeCodeRuntime;

package/src/domains/providers/runtimes/claude/claude-sdk.ts

@@ -0,0 +1,38 @@
+import type { Api, Model } from "../../../../engine/types.js";
+
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+import {
+	CLAUDE_CODE_AUTH_NOTICE,
+	CLAUDE_CODE_MODELS,
+	claudeCodeCapabilities,
+	synthesizeClaudeDelegatedModel,
+} from "./common.js";
+
+const claudeSdkRuntime: RuntimeDescriptor = {
+	id: "claude-sdk",
+	displayName: "Claude Agent SDK",
+	kind: "sdk",
+	tier: "subscription",
+	apiFamily: "claude-agent-sdk",
+	auth: "claude-cli",
+	authNotice: CLAUDE_CODE_AUTH_NOTICE,
+	knownModels: [...CLAUDE_CODE_MODELS],
+	binaryName: "claude",
+	headlessCommand: "@anthropic-ai/claude-agent-sdk query()",
+	outputParser: "claude-agent-sdk-messages",
+	defaultCapabilities: claudeCodeCapabilities,
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthesizeClaudeDelegatedModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities: claudeCodeCapabilities,
+			runtimeId: "claude-sdk",
+			apiFamily: "claude-agent-sdk",
+		});
+	},
+};
+
+export default claudeSdkRuntime;

package/src/domains/providers/runtimes/claude/common.ts

@@ -0,0 +1,55 @@
+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 { RuntimeApiFamily } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+
+export const CLAUDE_CODE_AUTH_NOTICE =
+	"Uses your existing Claude Code login from the installed `claude` command. Clio stores no Claude Code credentials.";
+
+export const CLAUDE_CODE_MODELS: ReadonlyArray<string> = [
+	"sonnet",
+	"opus",
+	"haiku",
+	"claude-sonnet-4-5",
+	"claude-opus-4-5",
+	"claude-haiku-4-5",
+	"claude-3-7-sonnet-latest",
+];
+
+export const claudeCodeCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "anthropic",
+	reasoning: true,
+	thinkingFormat: "anthropic-extended",
+	vision: true,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 200000,
+	maxTokens: 8192,
+};
+
+export function synthesizeClaudeDelegatedModel(input: {
+	target: TargetDescriptor;
+	wireModelId: string;
+	kb: KnowledgeBaseHit | null;
+	defaultCapabilities: CapabilityFlags;
+	runtimeId: string;
+	apiFamily: RuntimeApiFamily;
+}): Model<Api> {
+	return synthesizeCatalogBackedModel({
+		target: input.target,
+		wireModelId: input.wireModelId,
+		kb: input.kb,
+		defaultCapabilities: input.defaultCapabilities,
+		runtimeId: input.runtimeId,
+		api: input.apiFamily,
+		provider: "anthropic",
+		defaultBaseUrl: "claude-code://local",
+	});
+}

package/src/domains/providers/runtimes/cloud/alcf.ts

@@ -0,0 +1,171 @@
+import type { Api, Model } from "../../../../engine/types.js";
+
+import { 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 { withAsIs } from "../common/local-synth.js";
+import { synthesizeOpenAICompatModel } from "../protocol/openai-compat.js";
+
+const CATALOG_URL = "https://inference-api.alcf.anl.gov/resource_server/list-endpoints";
+const GATEWAY_ORIGIN = "https://inference-api.alcf.anl.gov/resource_server";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "openai",
+	reasoning: true,
+	vision: false,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 32768,
+	maxTokens: 4096,
+};
+
+const KNOWN_MODELS: string[] = [
+	"openai/gpt-oss-120b",
+	"openai/gpt-oss-20b",
+	"gpt-oss-120b",
+	"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+	"meta-llama/Llama-4-Scout-17B-16E-Instruct",
+];
+
+type AlcfCluster = string;
+
+export function clusterFromUrl(url: string | undefined): AlcfCluster | null {
+	if (!url) return null;
+	const match = /\/resource_server\/([^/]+)\//.exec(url);
+	return match ? (match[1] ?? null) : null;
+}
+
+export function frameworkForCluster(cluster: AlcfCluster): string {
+	return cluster === "metis" ? "api" : "vllm";
+}
+
+interface CatalogPayload {
+	clusters?: Record<string, { frameworks?: Record<string, { models?: unknown }> }>;
+}
+
+interface JobsPayload {
+	running?: Array<{ Models?: unknown }>;
+}
+
+export function catalogModels(payload: CatalogPayload, cluster: string, framework: string): string[] {
+	const models = payload.clusters?.[cluster]?.frameworks?.[framework]?.models;
+	if (!Array.isArray(models)) return [];
+	return models.map((model) => String(model).trim()).filter((model) => model.length > 0);
+}
+
+export function runningModels(payload: JobsPayload): string[] {
+	const out: string[] = [];
+	for (const job of payload.running ?? []) {
+		for (const raw of String(job.Models ?? "").split(",")) {
+			const id = raw.trim();
+			if (id.length > 0) out.push(id);
+		}
+	}
+	return out;
+}
+
+function dedupe(ids: ReadonlyArray<string>): string[] {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const id of ids) {
+		if (seen.has(id)) continue;
+		seen.add(id);
+		out.push(id);
+	}
+	return out;
+}
+
+function authHeaders(ctx: ProbeContext): Record<string, string> {
+	return { Authorization: `Bearer ${ctx.authToken}`, Accept: "application/json" };
+}
+
+async function discover(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
+	if (!target.url) return { ok: false, error: "ALCF target has no url" };
+	const cluster = clusterFromUrl(target.url);
+	if (!cluster) {
+		return { ok: false, error: `cannot determine ALCF cluster from url ${target.url}` };
+	}
+	if (!ctx.authToken) {
+		return { ok: false, error: "ALCF requires Globus auth; run `clio-coder auth login alcf`." };
+	}
+
+	const framework = frameworkForCluster(cluster);
+	const headers = authHeaders(ctx);
+	const catalog = await probeJson<CatalogPayload>({
+		url: CATALOG_URL,
+		headers,
+		timeoutMs: ctx.httpTimeoutMs,
+		...(ctx.signal ? { signal: ctx.signal } : {}),
+	});
+	if (!catalog.ok || !catalog.data) {
+		const reason = catalog.error ?? "unknown error";
+		const hint = reason.includes("401") ? " (token expired or rejected; run `clio-coder auth login alcf` again)" : "";
+		return {
+			ok: false,
+			error: `ALCF endpoint catalog unreachable: ${reason}${hint}`,
+			...(catalog.latencyMs !== undefined ? { latencyMs: catalog.latencyMs } : {}),
+		};
+	}
+
+	const fromCatalog = catalogModels(catalog.data, cluster, framework);
+	let live: string[] = [];
+	try {
+		const jobs = await probeJson<JobsPayload>({
+			url: `${GATEWAY_ORIGIN}/${cluster}/jobs`,
+			headers,
+			timeoutMs: Math.min(ctx.httpTimeoutMs, 12_000),
+			...(ctx.signal ? { signal: ctx.signal } : {}),
+		});
+		if (jobs.ok && jobs.data) live = runningModels(jobs.data);
+	} catch {
+		// /jobs is enrichment only; catalog discovery is authoritative enough.
+	}
+
+	const models = dedupe([...fromCatalog, ...live]);
+	const result: ProbeResult = { ok: true, models };
+	if (catalog.latencyMs !== undefined) result.latencyMs = catalog.latencyMs;
+	if (models.length === 0) {
+		result.notes = [`ALCF ${cluster}/${framework} reported no models; the gateway may have no running jobs.`];
+	}
+	return result;
+}
+
+const alcfRuntime: RuntimeDescriptor = {
+	id: "alcf",
+	displayName: "ALCF Inference (Globus)",
+	kind: "http",
+	tier: "cloud",
+	apiFamily: "openai-completions",
+	auth: "oauth",
+	knownModels: KNOWN_MODELS,
+	defaultCapabilities,
+	probe(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
+		return discover(target, ctx);
+	},
+	async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {
+		const result = await discover(target, ctx);
+		return result.models ?? [];
+	},
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		const model = synthesizeOpenAICompatModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			apiFamily: "openai-completions",
+			provider: "alcf",
+			baseUrlForTarget: withAsIs,
+		});
+		const meta = (model as Model<Api> & { clio?: { chatTemplateKwargsUnsupported?: boolean } }).clio;
+		if (meta) meta.chatTemplateKwargsUnsupported = true;
+		return model;
+	},
+};
+
+export default alcfRuntime;

package/src/domains/providers/runtimes/cloud/anthropic-max.ts

@@ -0,0 +1,71 @@
+import type { Api, Model } from "../../../../engine/types.js";
+
+import { listCatalogModelsForRuntime, synthesizeCatalogBackedModel } from "../../catalog.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { ProbeContext, RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "anthropic",
+	reasoning: true,
+	thinkingFormat: "anthropic-extended",
+	vision: true,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 200000,
+	maxTokens: 8192,
+};
+
+/**
+ * Claude Pro/Max subscription runtime (OAuth).
+ *
+ * Mirrors the `openai-codex` subscription runtime for Anthropic: an
+ * `anthropic-messages` HTTP runtime whose credential is an OAuth access token
+ * minted from a Claude Pro/Max subscription rather than an API key. pi-ai owns
+ * the entire mechanism — `anthropicOAuthProvider` runs the login/refresh flow,
+ * and the anthropic provider auto-detects the OAuth token (`sk-ant-oat...`) to
+ * switch to Bearer auth, attach the required `oauth-2025-04-20` beta, and apply
+ * the Claude Code identity. Clio only has to register the runtime and route the
+ * credential.
+ *
+ * The registry id is `anthropic-max` because the pi-ai OAuth provider id is
+ * `anthropic`, which already names the api-key Anthropic runtime. `oauthProviderId`
+ * bridges this runtime back to that provider so login/refresh/storage all key on
+ * `anthropic`, leaving the api-key path untouched.
+ */
+const anthropicMaxRuntime: RuntimeDescriptor = {
+	id: "anthropic-max",
+	displayName: "Anthropic (Claude Pro/Max)",
+	kind: "http",
+	tier: "cloud",
+	apiFamily: "anthropic-messages",
+	auth: "oauth",
+	oauthProviderId: "anthropic",
+	authNotice:
+		"Connects with your Claude Pro/Max subscription via OAuth (the same path Claude Code uses). " +
+		"Using subscription credentials outside Anthropic's first-party apps may not align with their " +
+		"terms of service; enable at your own discretion.",
+	defaultCapabilities,
+	async probeModels(_target: TargetDescriptor, _ctx: ProbeContext): Promise<string[]> {
+		return listCatalogModelsForRuntime("anthropic-max").map((model) => model.id);
+	},
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthesizeCatalogBackedModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			runtimeId: "anthropic-max",
+			api: "anthropic-messages",
+			provider: "anthropic",
+			defaultBaseUrl: "https://api.anthropic.com",
+		});
+	},
+};
+
+export default anthropicMaxRuntime;

package/src/domains/providers/runtimes/cloud/anthropic.ts

@@ -0,0 +1,43 @@
+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 { TargetDescriptor } from "../../types/target-descriptor.js";
+import { synthesizeAnthropicMessagesModel } from "../protocol/anthropic-messages.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "anthropic",
+	reasoning: true,
+	thinkingFormat: "anthropic-extended",
+	vision: true,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 200000,
+	maxTokens: 8192,
+};
+
+const anthropicRuntime: RuntimeDescriptor = {
+	id: "anthropic",
+	displayName: "Anthropic",
+	kind: "http",
+	tier: "cloud",
+	apiFamily: "anthropic-messages",
+	auth: "api-key",
+	credentialsEnvVar: "ANTHROPIC_API_KEY",
+	defaultCapabilities,
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null) {
+		return synthesizeAnthropicMessagesModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			provider: "anthropic",
+			defaultBaseUrl: "https://api.anthropic.com",
+		});
+	},
+};
+
+export default anthropicRuntime;

package/src/domains/providers/runtimes/cloud/bedrock.ts

@@ -0,0 +1,35 @@
+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 { TargetDescriptor } from "../../types/target-descriptor.js";
+import { synthesizeBedrockModel } from "../protocol/bedrock.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "anthropic",
+	reasoning: true,
+	thinkingFormat: "anthropic-extended",
+	vision: false,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 200000,
+	maxTokens: 8192,
+};
+
+const bedrockRuntime: RuntimeDescriptor = {
+	id: "bedrock",
+	displayName: "Amazon Bedrock",
+	kind: "http",
+	tier: "cloud",
+	apiFamily: "bedrock-converse-stream",
+	auth: "aws-sdk",
+	defaultCapabilities,
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null) {
+		return synthesizeBedrockModel({ target, wireModelId, kb, defaultCapabilities });
+	},
+};
+
+export default bedrockRuntime;

package/src/domains/providers/runtimes/cloud/deepseek.ts

@@ -0,0 +1,50 @@
+import type { Api, Model } from "../../../../engine/types.js";
+
+import { listCatalogModelsForRuntime, synthesizeCatalogBackedModel } from "../../catalog.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { ProbeContext, RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "openai",
+	reasoning: true,
+	thinkingFormat: "deepseek-r1",
+	vision: false,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: 128000,
+	maxTokens: 65536,
+};
+
+const deepseekRuntime: RuntimeDescriptor = {
+	id: "deepseek",
+	displayName: "DeepSeek",
+	kind: "http",
+	tier: "cloud",
+	apiFamily: "openai-completions",
+	auth: "api-key",
+	credentialsEnvVar: "DEEPSEEK_API_KEY",
+	defaultCapabilities,
+	async probeModels(_target: TargetDescriptor, _ctx: ProbeContext): Promise<string[]> {
+		return listCatalogModelsForRuntime("deepseek").map((model) => model.id);
+	},
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		return synthesizeCatalogBackedModel({
+			target,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			runtimeId: "deepseek",
+			api: "openai-completions",
+			provider: "deepseek",
+			defaultBaseUrl: "https://api.deepseek.com",
+		});
+	},
+};
+
+export default deepseekRuntime;