@gajae-code/coding-agent 0.2.1 → 0.2.3

package/src/session/contribution-prep.ts

@@ -0,0 +1,320 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { AgentMessage } from "@gajae-code/agent-core";
+import type { AssistantMessage, ToolResultMessage, UserMessage } from "@gajae-code/ai";
+import { $ } from "bun";
+import { resolveGjcCommand } from "../task/gjc-command";
+import { shortenPath } from "../tools/render-utils";
+
+export const CONTRIBUTION_PREP_SCHEMA_VERSION = 1;
+
+const MAX_TRANSCRIPT_MESSAGES = 20;
+const MAX_TEXT_CHARS = 12000;
+const MAX_GIT_OUTPUT_CHARS = 60000;
+
+export interface ContributionPrepArtifact {
+	path: string;
+	description: string;
+}
+
+export interface ContributionPrepManifest {
+	schema_version: number;
+	source_session_id: string;
+	created_at: string;
+	cwd: string;
+	git_head: string | null;
+	changed_files: string[];
+	artifacts: ContributionPrepArtifact[];
+	redactions: string[];
+	recommended_output: string[];
+	worker_prompt_path: string;
+}
+
+export interface ContributionPrepResult {
+	manifestPath: string;
+	workerPromptPath: string;
+	artifactDir: string;
+	changedFiles: string[];
+	spawned: boolean;
+}
+
+export interface ContributionPrepOptions {
+	customInstructions?: string;
+	spawnWorker?: boolean;
+	artifactRoot?: string;
+	now?: Date;
+	spawn?: (args: string[], cwd: string, shell: boolean) => Promise<void>;
+}
+
+export interface ContributionPrepContext {
+	sessionId: string;
+	cwd: string;
+	sessionFile?: string;
+	messages: AgentMessage[];
+	customInstructions?: string;
+	now?: Date;
+}
+
+interface RedactionState {
+	labels: Set<string>;
+}
+
+function limitText(text: string, maxChars = MAX_TEXT_CHARS): string {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}\n\n[truncated ${text.length - maxChars} chars]`;
+}
+
+function replaceRegex(text: string, regex: RegExp, replacement: string, state: RedactionState, label: string): string {
+	if (!regex.test(text)) return text;
+	state.labels.add(label);
+	regex.lastIndex = 0;
+	return text.replace(regex, replacement);
+}
+
+export function redactContributionPrepText(
+	text: string,
+	cwd: string,
+	state: RedactionState = { labels: new Set() },
+): string {
+	let redacted = text;
+	redacted = replaceRegex(
+		redacted,
+		/\b(?:sk|pk|rk|xox[baprs])-[-_A-Za-z0-9]{12,}\b/g,
+		"[REDACTED_TOKEN]",
+		state,
+		"tokens",
+	);
+	redacted = replaceRegex(
+		redacted,
+		/\b(?:ghp_[A-Za-z0-9_]{12,}|gho_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,})\b/g,
+		"[REDACTED_TOKEN]",
+		state,
+		"tokens",
+	);
+	redacted = replaceRegex(
+		redacted,
+		/\b((?:ANTHROPIC|OPENAI|GITHUB|GOOGLE|GEMINI|KAGI|TAVILY|EXA|PERPLEXITY|ZAI|KIMI|BRAVE|SEARXNG|AWS)_[A-Z0-9_]*(?:KEY|TOKEN|SECRET|COOKIE|PASSWORD))\s*=\s*[^\s\n]+/gi,
+		"$1=[REDACTED_SECRET]",
+		state,
+		"provider_keys",
+	);
+	redacted = replaceRegex(
+		redacted,
+		/\b(Authorization|Proxy-Authorization)\s*:\s*(?:Bearer|Basic|Token)\s+[^\s\n]+/gi,
+		"$1: [REDACTED_AUTH_HEADER]",
+		state,
+		"auth_headers",
+	);
+	redacted = replaceRegex(redacted, /\b(Cookie|Set-Cookie)\s*:\s*[^\n]+/gi, "$1: [REDACTED_COOKIE]", state, "cookies");
+	redacted = replaceRegex(
+		redacted,
+		/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[0-1])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})[^\s)>'"]*/gi,
+		"[REDACTED_PRIVATE_ENDPOINT]",
+		state,
+		"private_endpoints",
+	);
+	const home = os.homedir();
+	if (home && redacted.includes(home)) {
+		state.labels.add("home_paths");
+		redacted = redacted.split(home).join("~");
+	}
+	const normalizedCwd = path.resolve(cwd);
+	if (normalizedCwd && redacted.includes(normalizedCwd)) {
+		state.labels.add("cwd_paths");
+		redacted = redacted.split(normalizedCwd).join(shortenPath(normalizedCwd));
+	}
+	return redacted;
+}
+
+function contentText(content: UserMessage["content"] | AssistantMessage["content"]): string {
+	if (typeof content === "string") return content;
+	return content
+		.map(part => {
+			if (part.type === "text") return part.text;
+			if (part.type === "toolCall") return `[tool call: ${part.name}] ${JSON.stringify(part.arguments)}`;
+			if (part.type === "image") return "[image]";
+			return `[${part.type}]`;
+		})
+		.join("\n");
+}
+
+function formatMessage(message: AgentMessage): string {
+	if (message.role === "user" || message.role === "assistant") {
+		return `## ${message.role}\n\n${contentText(message.content)}\n`;
+	}
+	if (message.role === "toolResult") {
+		const tool = message as ToolResultMessage;
+		return `## toolResult: ${tool.toolName}\n\n${typeof tool.content === "string" ? tool.content : JSON.stringify(tool.content)}\n`;
+	}
+	return `## ${message.role}\n\n${JSON.stringify(message)}\n`;
+}
+
+async function gitOutput(cwd: string, args: string[], maxChars = MAX_GIT_OUTPUT_CHARS): Promise<string> {
+	try {
+		const output = await $`git ${args}`.cwd(cwd).quiet().text();
+		return limitText(output.trim(), maxChars);
+	} catch {
+		return "";
+	}
+}
+
+async function changedFiles(cwd: string): Promise<string[]> {
+	const output = await gitOutput(cwd, ["status", "--short"]);
+	return output
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean)
+		.map(line => line.replace(/^..\s+/, ""));
+}
+
+async function writeArtifact(
+	dir: string,
+	name: string,
+	description: string,
+	text: string,
+): Promise<ContributionPrepArtifact> {
+	const filePath = path.join(dir, name);
+	await Bun.write(filePath, `${text.trimEnd()}\n`);
+	return { path: filePath, description };
+}
+
+export function buildContributionPrepWorkerPrompt(manifestPath: string): string {
+	return [
+		"Prepare a maintainer-friendly contribution draft from the redacted context dump.",
+		"Read the manifest and referenced artifact file pointers. Do not assume transcript context was inlined here.",
+		`Manifest: ${manifestPath}`,
+		"Produce structured markdown with: title, problem summary, reproduction/context, proposed fix or implementation plan, affected files, tests to run, and uncertainty/remaining risks.",
+		"Do not create GitHub issues, open PRs, push branches, or perform remote writes unless the user explicitly confirms that action in this fresh session.",
+	].join("\n");
+}
+
+export async function prepareContributionPrep(
+	context: ContributionPrepContext,
+	options: ContributionPrepOptions = {},
+): Promise<ContributionPrepResult> {
+	const createdAt = (options.now ?? context.now ?? new Date()).toISOString();
+	const safeTimestamp = createdAt.replace(/[:.]/g, "-");
+	const artifactDir = path.join(
+		options.artifactRoot ?? path.join(context.cwd, ".gjc", "contribution-prep"),
+		safeTimestamp,
+	);
+	await fs.mkdir(artifactDir, { recursive: true });
+
+	const redactions: RedactionState = { labels: new Set() };
+	const recentMessages = context.messages.slice(-MAX_TRANSCRIPT_MESSAGES);
+	const artifacts: ContributionPrepArtifact[] = [];
+	const redact = (text: string) => redactContributionPrepText(text, context.cwd, redactions);
+
+	artifacts.push(
+		await writeArtifact(
+			artifactDir,
+			"transcript.md",
+			"Redacted recent transcript window",
+			redact(recentMessages.map(formatMessage).join("\n---\n")),
+		),
+	);
+	artifacts.push(
+		await writeArtifact(
+			artifactDir,
+			"summary.md",
+			"Current session summary and operator instructions",
+			redact(
+				[
+					`# Contribution prep context`,
+					`Source session: ${context.sessionId}`,
+					`Session file: ${context.sessionFile ?? "(none)"}`,
+					`Working directory: ${context.cwd}`,
+					options.customInstructions || context.customInstructions
+						? `Custom instructions: ${options.customInstructions ?? context.customInstructions}`
+						: "Custom instructions: (none)",
+				].join("\n"),
+			),
+		),
+	);
+
+	const gitHead = (await gitOutput(context.cwd, ["rev-parse", "HEAD"])) || null;
+	const files = await changedFiles(context.cwd);
+	artifacts.push(
+		await writeArtifact(artifactDir, "changed-files.txt", "Changed files from git status", redact(files.join("\n"))),
+	);
+	artifacts.push(
+		await writeArtifact(
+			artifactDir,
+			"git-diff.patch",
+			"Bounded redacted git diff",
+			redact(await gitOutput(context.cwd, ["diff", "--no-ext-diff"])),
+		),
+	);
+	artifacts.push(
+		await writeArtifact(
+			artifactDir,
+			"environment.md",
+			"Redacted environment and reproduction metadata",
+			redact(
+				[
+					`cwd: ${context.cwd}`,
+					`git_head: ${gitHead ?? "unknown"}`,
+					`platform: ${process.platform}`,
+					`arch: ${process.arch}`,
+					`bun: ${Bun.version}`,
+				].join("\n"),
+			),
+		),
+	);
+
+	const manifestPath = path.join(artifactDir, "manifest.json");
+	const workerPromptPath = path.join(artifactDir, "worker-prompt.md");
+	await Bun.write(workerPromptPath, `${buildContributionPrepWorkerPrompt(manifestPath)}\n`);
+
+	const manifest: ContributionPrepManifest = {
+		schema_version: CONTRIBUTION_PREP_SCHEMA_VERSION,
+		source_session_id: context.sessionId,
+		created_at: createdAt,
+		cwd: redact(context.cwd),
+		git_head: gitHead,
+		changed_files: files,
+		artifacts,
+		redactions: [...redactions.labels].sort(),
+		recommended_output: [
+			"title",
+			"problem summary",
+			"reproduction/context",
+			"proposed fix or implementation plan",
+			"affected files",
+			"tests to run",
+			"uncertainty / remaining risks",
+		],
+		worker_prompt_path: workerPromptPath,
+	};
+	await Bun.write(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+	let spawned = false;
+	if (options.spawnWorker) {
+		const spawn =
+			options.spawn ??
+			(async (args, cwd, shell) => {
+				if (shell) {
+					Bun.spawn({
+						cmd: args,
+						cwd,
+						stdout: "inherit",
+						stderr: "inherit",
+						stdin: "inherit",
+						windowsVerbatimArguments: true,
+					});
+					return;
+				}
+				Bun.spawn(args, { cwd, stdout: "inherit", stderr: "inherit", stdin: "inherit" });
+			});
+		const command = resolveGjcCommand();
+		await spawn(
+			[command.cmd, ...command.args, "--no-skills", "--", `@${workerPromptPath}`],
+			context.cwd,
+			command.shell,
+		);
+		spawned = true;
+	}
+
+	return { manifestPath, workerPromptPath, artifactDir, changedFiles: files, spawned };
+}

package/src/session/session-manager.ts

@@ -176,6 +176,8 @@ export interface SessionInitEntry extends SessionEntryBase {
 	tools: string[];
 	/** Output schema if structured output was requested */
 	outputSchema?: unknown;
+	/** Fork-context seed metadata for subagent debugging/replay. */
+	forkContext?: unknown;
 }
 
 /** Mode change entry - tracks agent mode transitions (e.g. plan mode). */
@@ -2714,7 +2716,13 @@ export class SessionManager {
 	}
 
 	/** Append session init metadata (for subagent debugging/replay). Returns entry id. */
-	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[]; outputSchema?: unknown }): string {
+	appendSessionInit(init: {
+		systemPrompt: string;
+		task: string;
+		tools: string[];
+		outputSchema?: unknown;
+		forkContext?: unknown;
+	}): string {
 		const entry: SessionInitEntry = {
 			type: "session_init",
 			id: generateId(this.#byId),

package/src/setup/model-onboarding-guidance.ts

@@ -1,5 +1,6 @@
 export const MODEL_ONBOARDING_API_PROVIDER_COMMAND =
 	"/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>";
+export const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = "/provider add --preset <minimax|minimax-cn|glm>";
 
 export const MODEL_ONBOARDING_SETUP_COMMAND = "gjc setup provider";
 export const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or /login [provider-id]";
@@ -9,14 +10,15 @@ export function formatModelOnboardingGuidance(): string {
 		"Model selection only shows configured providers.",
 		"Assignment targets are DEFAULT plus the GJC role agents: EXECUTOR, ARCHITECT, PLANNER, and CRITIC.",
 		"Legacy model-role aliases are compatibility-only and are not shown as assignment targets.",
-		`API-compatible providers: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}).`,
+		`Provider presets: ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND} --preset <preset>).`,
+		`API-compatible custom providers: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}.`,
 		`OAuth/subscription providers: ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
 		"Then run /model to select a configured model or assign it to a target.",
 	].join("\n");
 }
 
 export function formatModelOnboardingInlineHint(): string {
-	return `Add API-compatible providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); OAuth/subscription with ${MODEL_ONBOARDING_OAUTH_COMMAND}; then run /model for DEFAULT, EXECUTOR, ARCHITECT, PLANNER, and CRITIC.`;
+	return `Add MiniMax/GLM presets with ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND}; custom API providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); OAuth/subscription with ${MODEL_ONBOARDING_OAUTH_COMMAND}; then run /model for DEFAULT, EXECUTOR, ARCHITECT, PLANNER, and CRITIC.`;
 }
 
 export function formatNoModelOnboardingError(): string {
@@ -27,7 +29,8 @@ export function formatNoCredentialOnboardingError(providerId: string): string {
 	return [
 		`No credentials found for ${providerId}.`,
 		"",
-		`For API-compatible providers, configure credentials with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}).`,
+		`For MiniMax/GLM presets, configure credentials with ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND} --preset <preset>).`,
+		`For custom API-compatible providers, use ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}.`,
 		`For OAuth/subscription providers, use ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
 		"Then run /model to select a configured model or assign it to DEFAULT, EXECUTOR, ARCHITECT, PLANNER, or CRITIC.",
 	].join("\n");

package/src/setup/provider-onboarding.ts

@@ -5,14 +5,16 @@ import { YAML } from "bun";
 import { type ModelsConfig, ModelsConfigSchema } from "../config/models-config-schema";
 
 export type ProviderCompatibility = "openai" | "anthropic";
+export type ProviderSetupApi = "openai-responses" | "openai-completions" | "anthropic-messages";
 
 export interface ProviderSetupInput {
-	compatibility: ProviderCompatibility;
-	providerId: string;
-	baseUrl: string;
+	compatibility?: ProviderCompatibility;
+	preset?: string;
+	providerId?: string;
+	baseUrl?: string;
 	apiKey?: string;
 	apiKeyEnv?: string;
-	models: string[];
+	models?: string[];
 	modelsPath?: string;
 	force?: boolean;
 }
@@ -20,19 +22,93 @@ export interface ProviderSetupInput {
 export interface ProviderSetupResult {
 	providerId: string;
 	compatibility: ProviderCompatibility;
-	api: "openai-responses" | "anthropic-messages";
+	api: ProviderSetupApi;
 	baseUrl: string;
 	modelIds: string[];
 	modelsPath: string;
 	redactedApiKey: string;
 	credentialSource: "literal" | "env";
+	preset?: string;
+	presetName?: string;
 }
 
 type ProviderConfig = NonNullable<NonNullable<ModelsConfig["providers"]>[string]>;
+type ProviderCompatConfig = NonNullable<ProviderConfig["compat"]>;
+
+interface ProviderPreset {
+	id: string;
+	aliases: readonly string[];
+	name: string;
+	description: string;
+	compatibility: ProviderCompatibility;
+	api: ProviderSetupApi;
+	providerId: string;
+	baseUrl: string;
+	apiKeyEnv: string;
+	models: readonly string[];
+	compat?: ProviderCompatConfig;
+}
 
 const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 const REDACT_PREFIX = 4;
 const REDACT_SUFFIX = 4;
+// Preset compat values are onboarding snapshots for generated models.yml entries.
+// Keep them aligned with provider descriptor behavior without importing descriptor internals into setup UX.
+const MINIMAX_OPENAI_COMPAT: ProviderCompatConfig = {
+	supportsStore: false,
+	supportsDeveloperRole: false,
+	supportsReasoningEffort: false,
+	reasoningContentField: "reasoning_content",
+};
+
+const GLM_OPENAI_COMPAT: ProviderCompatConfig = {
+	supportsDeveloperRole: false,
+	supportsReasoningEffort: false,
+	thinkingFormat: "zai",
+	reasoningContentField: "reasoning_content",
+};
+
+export const PROVIDER_PRESETS: readonly ProviderPreset[] = [
+	{
+		id: "minimax",
+		aliases: ["minimax-code"],
+		name: "MiniMax Coding Plan",
+		description: "OpenAI-compatible MiniMax Coding Plan endpoint",
+		compatibility: "openai",
+		api: "openai-completions",
+		providerId: "minimax-code",
+		baseUrl: "https://api.minimax.io/v1",
+		apiKeyEnv: "MINIMAX_CODE_API_KEY",
+		models: ["MiniMax-M2.5"],
+		compat: MINIMAX_OPENAI_COMPAT,
+	},
+	{
+		id: "minimax-cn",
+		aliases: ["minimax-code-cn", "minimaxi"],
+		name: "MiniMax Coding Plan (China)",
+		description: "OpenAI-compatible MiniMax China endpoint",
+		compatibility: "openai",
+		api: "openai-completions",
+		providerId: "minimax-code-cn",
+		baseUrl: "https://api.minimaxi.com/v1",
+		apiKeyEnv: "MINIMAX_CODE_CN_API_KEY",
+		models: ["MiniMax-M2.5"],
+		compat: MINIMAX_OPENAI_COMPAT,
+	},
+	{
+		id: "glm",
+		aliases: ["zai", "z-ai", "bigmodel"],
+		name: "GLM / zAI",
+		description: "OpenAI-compatible GLM endpoint from zAI/BigModel",
+		compatibility: "openai",
+		api: "openai-completions",
+		providerId: "glm-proxy",
+		baseUrl: "https://api.z.ai/api/paas/v4",
+		apiKeyEnv: "ZAI_API_KEY",
+		models: ["glm-4.6"],
+		compat: GLM_OPENAI_COMPAT,
+	},
+];
 
 export function getDefaultModelsPath(): string {
 	return path.join(getAgentDir(), "models.yml");
@@ -51,6 +127,19 @@ export function parseProviderCompatibility(value: string): ProviderCompatibility
 	throw new Error("Provider compatibility must be 'openai' or 'anthropic'.");
 }
 
+export function findProviderPreset(value: string | undefined): ProviderPreset | undefined {
+	const normalized = value?.trim().toLowerCase();
+	if (!normalized) return undefined;
+	return PROVIDER_PRESETS.find(preset => preset.id === normalized || preset.aliases.includes(normalized));
+}
+
+export function formatProviderPresetList(): string {
+	return PROVIDER_PRESETS.map(preset => {
+		const aliases = preset.aliases.length > 0 ? ` (aliases: ${preset.aliases.join(", ")})` : "";
+		return `${preset.id}${aliases}: ${preset.description}`;
+	}).join("\n");
+}
+
 export function parseModelList(values: readonly string[]): string[] {
 	const models = values
 		.flatMap(value => value.split(","))
@@ -65,23 +154,82 @@ export function redactSecret(secret: string): string {
 	return `${trimmed.slice(0, REDACT_PREFIX)}…${trimmed.slice(-REDACT_SUFFIX)}`;
 }
 
-function apiForCompatibility(compatibility: ProviderCompatibility): ProviderSetupResult["api"] {
+function apiForCompatibility(compatibility: ProviderCompatibility): ProviderSetupApi {
 	return compatibility === "openai" ? "openai-responses" : "anthropic-messages";
 }
 
+function resolvePresetInput(input: ProviderSetupInput): {
+	compatibility: ProviderCompatibility;
+	preset?: ProviderPreset;
+	providerId?: string;
+	baseUrl?: string;
+	apiKey?: string;
+	apiKeyEnv?: string;
+	models: readonly string[];
+	api: ProviderSetupApi;
+	compat?: ProviderCompatConfig;
+} {
+	const preset = input.preset ? findProviderPreset(input.preset) : undefined;
+	if (input.preset && !preset) {
+		throw new Error(`Unknown provider preset '${input.preset}'. Available presets:\n${formatProviderPresetList()}`);
+	}
+	if (preset && input.compatibility && input.compatibility !== preset.compatibility) {
+		throw new Error(
+			`Provider preset '${preset.id}' is ${preset.compatibility}-compatible; omit --compat or use '${preset.compatibility}'.`,
+		);
+	}
+	if (preset && input.baseUrl !== undefined) {
+		throw new Error(
+			`Provider preset '${preset.id}' uses a fixed base URL; omit --base-url or use --compat openai for a custom provider.`,
+		);
+	}
+	if (preset && input.models && input.models.length > 0) {
+		throw new Error(
+			`Provider preset '${preset.id}' uses fixed model ids; omit --model or use --compat openai for a custom provider.`,
+		);
+	}
+	if (preset && input.apiKeyEnv !== undefined && input.apiKeyEnv.trim() !== preset.apiKeyEnv) {
+		throw new Error(
+			`Provider preset '${preset.id}' uses ${preset.apiKeyEnv}; omit --api-key-env or use --compat openai for a custom provider.`,
+		);
+	}
+	const compatibility = preset?.compatibility ?? input.compatibility;
+	if (!compatibility) {
+		throw new Error("Provider compatibility is required unless --preset is used.");
+	}
+	return {
+		compatibility,
+		preset,
+		providerId: input.providerId ?? preset?.providerId,
+		baseUrl: input.baseUrl ?? preset?.baseUrl,
+		apiKey: input.apiKey,
+		apiKeyEnv: input.apiKeyEnv ?? preset?.apiKeyEnv,
+		models: input.models && input.models.length > 0 ? input.models : (preset?.models ?? []),
+		api: preset?.api ?? apiForCompatibility(compatibility),
+		compat: preset?.compat,
+	};
+}
+
 function validateSetupInput(input: ProviderSetupInput): {
 	providerId: string;
 	baseUrl: string;
 	apiKey: string;
 	credentialSource: ProviderSetupResult["credentialSource"];
 	models: string[];
+	compatibility: ProviderCompatibility;
+	api: ProviderSetupApi;
+	compat?: ProviderCompatConfig;
+	preset?: ProviderPreset;
 } {
-	const providerId = normalizeProviderId(input.providerId);
+	const resolved = resolvePresetInput(input);
+	if (!resolved.providerId) throw new Error("Provider id is required.");
+	if (!resolved.baseUrl) throw new Error("Base URL is required.");
+	const providerId = normalizeProviderId(resolved.providerId);
 	if (!PROVIDER_ID_PATTERN.test(providerId)) {
 		throw new Error("Provider id must use lowercase letters, numbers, dots, underscores, or hyphens.");
 	}
 
-	const baseUrl = input.baseUrl.trim();
+	const baseUrl = resolved.baseUrl.trim();
 	let url: URL;
 	try {
 		url = new URL(baseUrl);
@@ -95,19 +243,29 @@ function validateSetupInput(input: ProviderSetupInput): {
 		throw new Error("Base URL must use https unless it targets localhost or a loopback address.");
 	}
 
-	const apiKeyEnv = input.apiKeyEnv?.trim();
+	const apiKeyEnv = resolved.apiKeyEnv?.trim();
 	if (apiKeyEnv) {
 		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(apiKeyEnv)) {
 			throw new Error("API key environment variable must be a valid environment variable name.");
 		}
 	}
-	const apiKey = apiKeyEnv ?? input.apiKey?.trim() ?? "";
+	const apiKey = apiKeyEnv ?? resolved.apiKey?.trim() ?? "";
 	if (!apiKey) throw new Error("API key is required.");
 
-	const models = parseModelList(input.models);
+	const models = parseModelList(resolved.models);
 	if (models.length === 0) throw new Error("At least one model id is required.");
 
-	return { providerId, baseUrl, apiKey, credentialSource: apiKeyEnv ? "env" : "literal", models };
+	return {
+		providerId,
+		baseUrl,
+		apiKey,
+		credentialSource: apiKeyEnv ? "env" : "literal",
+		models,
+		compatibility: resolved.compatibility,
+		api: resolved.api,
+		compat: resolved.compat,
+		preset: resolved.preset,
+	};
 }
 
 async function readModelsConfig(modelsPath: string): Promise<ModelsConfig> {
@@ -140,16 +298,16 @@ export async function addApiCompatibleProvider(input: ProviderSetupInput): Promi
 	const validated = validateSetupInput(input);
 	const modelsPath = input.modelsPath ?? getDefaultModelsPath();
 	const existing = await readModelsConfig(modelsPath);
-	const api = apiForCompatibility(input.compatibility);
 	if (existing.providers?.[validated.providerId] && !input.force) {
 		throw new Error(`Provider '${validated.providerId}' already exists. Use --force to replace it.`);
 	}
 	const provider: ProviderConfig = {
 		baseUrl: validated.baseUrl,
-		api,
+		api: validated.api,
 		auth: "apiKey",
 		models: validated.models.map(id => ({ id })),
 	};
+	if (validated.compat) provider.compat = validated.compat;
 	if (validated.credentialSource === "env") {
 		provider.apiKeyEnv = validated.apiKey;
 	} else {
@@ -165,13 +323,15 @@ export async function addApiCompatibleProvider(input: ProviderSetupInput): Promi
 	await writeModelsConfig(modelsPath, next);
 	return {
 		providerId: validated.providerId,
-		compatibility: input.compatibility,
-		api,
+		compatibility: validated.compatibility,
+		api: validated.api,
 		baseUrl: validated.baseUrl,
 		modelIds: validated.models,
 		modelsPath,
 		redactedApiKey: redactSecret(validated.apiKey),
 		credentialSource: validated.credentialSource,
+		preset: validated.preset?.id,
+		presetName: validated.preset?.name,
 	};
 }
 
@@ -189,6 +349,7 @@ function isLocalHttpHost(hostname: string): boolean {
 export function formatProviderSetupResult(result: ProviderSetupResult): string {
 	return [
 		`Provider '${result.providerId}' configured as ${result.compatibility}-compatible.`,
+		...(result.presetName ? [`Preset: ${result.presetName}`] : []),
 		`Models: ${result.modelIds.join(", ")}`,
 		`Base URL: ${result.baseUrl}`,
 		`API key: ${result.credentialSource === "env" ? `${result.redactedApiKey} (environment variable)` : result.redactedApiKey}`,