@gajae-code/coding-agent 0.2.1 → 0.2.3

package/src/cli/setup-cli.ts

@@ -16,6 +16,7 @@ import {
 import { theme } from "../modes/theme/theme";
 import {
 	addApiCompatibleProvider,
+	formatProviderPresetList,
 	formatProviderSetupResult,
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
@@ -28,6 +29,7 @@ export interface SetupCommandArgs {
 		json?: boolean;
 		check?: boolean;
 		force?: boolean;
+		preset?: string;
 		compat?: string;
 		provider?: string;
 		baseUrl?: string;
@@ -42,6 +44,7 @@ const VALID_COMPONENTS: SetupComponent[] = ["defaults", "hooks", "provider", "py
 function hasProviderSetupFlags(flags: SetupCommandArgs["flags"]): boolean {
 	return (
 		flags.compat !== undefined ||
+		flags.preset !== undefined ||
 		flags.provider !== undefined ||
 		flags.baseUrl !== undefined ||
 		flags.apiKeyEnv !== undefined ||
@@ -57,7 +60,7 @@ function rejectProviderFlagsOutsideProvider(component: SetupComponent, flags: Se
 	console.error(chalk.red("Provider setup flags require the explicit `provider` component."));
 	console.error(
 		chalk.dim(
-			`Run: ${APP_NAME} setup provider --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <id>`,
+			`Run: ${APP_NAME} setup provider --preset <minimax|glm> or ${APP_NAME} setup provider --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <id>`,
 		),
 	);
 	process.exit(1);
@@ -87,6 +90,8 @@ export function parseSetupArgs(args: string[]): SetupCommandArgs | undefined {
 			flags.force = true;
 		} else if (arg === "--compat") {
 			flags.compat = args[++i];
+		} else if (arg === "--preset") {
+			flags.preset = args[++i];
 		} else if (arg === "--provider") {
 			flags.provider = args[++i];
 		} else if (arg === "--base-url") {
@@ -190,6 +195,7 @@ export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 async function handleProviderSetup(flags: {
 	json?: boolean;
 	force?: boolean;
+	preset?: string;
 	compat?: string;
 	provider?: string;
 	baseUrl?: string;
@@ -199,20 +205,25 @@ async function handleProviderSetup(flags: {
 }): Promise<void> {
 	try {
 		const missing: string[] = [];
-		if (!flags.compat) missing.push("--compat");
-		if (!flags.provider) missing.push("--provider");
-		if (!flags.baseUrl) missing.push("--base-url");
-		if (!flags.apiKeyEnv) missing.push("--api-key-env");
-		if (!flags.model || flags.model.length === 0) missing.push("--model");
+		if (!flags.preset) {
+			if (!flags.compat) missing.push("--compat");
+			if (!flags.provider) missing.push("--provider");
+			if (!flags.baseUrl) missing.push("--base-url");
+			if (!flags.apiKeyEnv) missing.push("--api-key-env");
+			if (!flags.model || flags.model.length === 0) missing.push("--model");
+		}
 		if (missing.length > 0) {
-			throw new Error(`Missing required provider setup option(s): ${missing.join(", ")}`);
+			throw new Error(
+				`Missing required provider setup option(s): ${missing.join(", ")}. Or use --preset <preset>.\nAvailable presets:\n${formatProviderPresetList()}`,
+			);
 		}
 		const result = await addApiCompatibleProvider({
-			compatibility: parseProviderCompatibility(flags.compat!),
-			providerId: flags.provider!,
-			baseUrl: flags.baseUrl!,
+			compatibility: flags.compat ? parseProviderCompatibility(flags.compat) : undefined,
+			preset: flags.preset,
+			providerId: flags.provider,
+			baseUrl: flags.baseUrl,
 			apiKeyEnv: flags.apiKeyEnv,
-			models: flags.model!,
+			models: flags.model,
 			modelsPath: flags.modelsPath,
 			force: flags.force,
 		});
@@ -400,18 +411,21 @@ ${chalk.bold("Usage:")}
 ${chalk.bold("Components:")}
   defaults  Install bundled GJC default workflow skills (default)
   hooks     Optional: install GJC native Codex UserPromptSubmit/Stop skill-state hooks
-  provider  Optional: add an OpenAI-compatible or Anthropic-compatible API provider
+  provider  Optional: add a preset, OpenAI-compatible, or Anthropic-compatible API provider
   python    Optional: verify a Python 3 interpreter is reachable for code execution
   stt       Optional: install speech-to-text dependencies (openai-whisper, recording tools)
 
 
 ${chalk.bold("Provider example:")}
+  ${APP_NAME} setup provider --preset minimax
+  ${APP_NAME} setup provider --preset glm
   MY_PROVIDER_KEY=sk-... ${APP_NAME} setup provider --compat openai --provider my-oai --base-url https://api.example.com/v1 --api-key-env MY_PROVIDER_KEY --model gpt-example
 
 ${chalk.bold("Options:")}
   -c, --check       Check if dependencies are installed without installing
   -f, --force       Overwrite existing default workflow skill files
   --json            Output status as JSON
+  --preset          Provider preset: minimax, minimax-cn, or glm (aliases include minimax-code and zai)
   --compat          Provider compatibility: openai or anthropic
   --provider        Provider id to add to models.yml
   --base-url        Provider API base URL

package/src/cli.ts

@@ -31,14 +31,20 @@ process.title = APP_NAME;
 
 const commands: CommandEntry[] = [
 	{ name: "codex-native-hook", load: () => import("./commands/codex-native-hook").then(m => m.default) },
-	{ name: "question", load: () => import("./commands/question").then(m => m.default) },
 	{ name: "state", load: () => import("./commands/state").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
 	{ name: "skills", load: () => import("./commands/skills").then(m => m.default) },
+	{ name: "session", load: () => import("./commands/session").then(m => m.default) },
 	{ name: "team", load: () => import("./commands/team").then(m => m.default) },
 	{ name: "ultragoal", load: () => import("./commands/ultragoal").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
+	{
+		name: "contribute-pr",
+		aliases: ["contribution-prep"],
+		load: () => import("./commands/contribution-prep").then(m => m.default),
+	},
 	{ name: "deep-interview", load: () => import("./commands/deep-interview").then(m => m.default) },
+	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
 ];
 

package/src/commands/contribution-prep.ts

@@ -0,0 +1,41 @@
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { prepareContributionPrep } from "../session/contribution-prep";
+
+function writeText(lines: string[]): void {
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+export default class ContributionPrep extends Command {
+	static description = "Dump redacted context and prepare a fresh contribute-pr worker prompt";
+	static strict = false;
+
+	static flags = {
+		"no-spawn": Flags.boolean({ description: "Only write artifacts; do not spawn a fresh GJC worker" }),
+		"source-session-id": Flags.string({ description: "Source session id to record in the manifest" }),
+		"artifact-root": Flags.string({ description: "Directory where contribute-pr artifacts are written" }),
+	};
+
+	static examples = ["gjc contribute-pr", "gjc contribute-pr --no-spawn"];
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(ContributionPrep);
+		const cwd = process.cwd();
+		const result = await prepareContributionPrep(
+			{
+				sessionId: flags["source-session-id"] ?? "cli",
+				cwd,
+				messages: [],
+			},
+			{
+				spawnWorker: !flags["no-spawn"],
+				artifactRoot: flags["artifact-root"],
+			},
+		);
+		writeText([
+			"Contribution prep artifacts written.",
+			`Manifest: ${result.manifestPath}`,
+			`Worker prompt: ${result.workerPromptPath}`,
+			`Spawned worker: ${result.spawned ? "yes" : "no"}`,
+		]);
+	}
+}

package/src/commands/deep-interview.ts

@@ -1,31 +1,38 @@
-import { Command } from "@gajae-code/utils/cli";
-import { syncSkillActiveState } from "../skill-state/active-state";
-import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { runNativeDeepInterviewCommand } from "../gjc-runtime/deep-interview-runtime";
 
 export default class DeepInterview extends Command {
-	static description = "Run private GJC deep-interview workflow commands";
+	static description = "Run native GJC deep-interview workflow";
 	static strict = false;
-	static examples = ["$ gjc deep-interview --help"];
+	static flags = {
+		quick: Flags.boolean({ description: "Seed a quick deep-interview run" }),
+		standard: Flags.boolean({ description: "Seed a standard deep-interview run" }),
+		deep: Flags.boolean({ description: "Seed a deep deep-interview run" }),
+		threshold: Flags.string({ description: "Override ambiguity threshold for kickoff" }),
+		"threshold-source": Flags.string({ description: "Describe the threshold override source" }),
+		"session-id": Flags.string({
+			description: "Route state/spec handoff through a session-scoped .gjc state directory",
+		}),
+		write: Flags.boolean({ description: "Persist a final deep-interview spec through the sanctioned GJC CLI/API" }),
+		stage: Flags.string({ description: 'Spec stage for --write (currently "final")' }),
+		slug: Flags.string({ description: "Safe slug for .gjc/specs/deep-interview-<slug>.md" }),
+		spec: Flags.string({ description: "Final spec markdown or a path to the final spec markdown" }),
+		handoff: Flags.string({ description: 'After --write, hand off to a workflow target (currently "ralplan")' }),
+		deliberate: Flags.boolean({
+			description: "Shortcut for --write handoff to ralplan in deliberate consensus mode",
+		}),
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+	static examples = [
+		'$ gjc deep-interview --standard "<idea>"',
+		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md",
+		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md --deliberate",
+	];
 
 	async run(): Promise<void> {
-		const cwd = process.cwd();
-		const result = await runGjcRuntimeBridgeWithHudSidecar("deep-interview", this.argv, {
-			cwd,
-			sidecarSkill: "deep-interview",
-			onHudPayload: payload =>
-				syncSkillActiveState({
-					cwd,
-					skill: "deep-interview",
-					active: payload.active ?? true,
-					phase: payload.phase,
-					sessionId: payload.session_id,
-					threadId: payload.thread_id,
-					turnId: payload.turn_id,
-					hud: payload.hud,
-					source: "gjc-runtime-bridge",
-				}),
-		});
-		if (result.error) process.stderr.write(`${result.error}\n`);
+		const result = await runNativeDeepInterviewCommand(this.argv, process.cwd());
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
 		process.exitCode = result.status;
 	}
 }

package/src/commands/launch.ts

@@ -155,7 +155,16 @@ export default class Index extends Command {
 			setProjectDir(launch.cwd);
 		}
 		const launchParsed = parseArgs(launch.args);
-		if (launchDefaultTmuxIfNeeded({ parsed: launchParsed, rawArgs: launch.args, cwd: launch.cwd })) return;
+		if (
+			launchDefaultTmuxIfNeeded({
+				parsed: launchParsed,
+				rawArgs: launch.args,
+				cwd: launch.cwd,
+				worktreeBranch: launch.worktree.enabled && !launch.worktree.detached ? launch.worktree.branchName : null,
+				project: launch.worktree.enabled ? launch.worktree.repoRoot : launch.cwd,
+			})
+		)
+			return;
 		await runRootCommand(launchParsed, launch.args);
 	}
 }

package/src/commands/ralplan.ts

@@ -1,31 +1,19 @@
 import { Command } from "@gajae-code/utils/cli";
-import { syncSkillActiveState } from "../skill-state/active-state";
-import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
+import { runNativeRalplanCommand } from "../gjc-runtime/ralplan-runtime";
 
 export default class Ralplan extends Command {
-	static description = "Run private GJC RALPLAN workflow commands";
+	static description = "Run native GJC RALPLAN consensus planning workflow";
 	static strict = false;
-	static examples = ["$ gjc ralplan --help"];
+	static examples = [
+		'$ gjc ralplan "<task description>"',
+		'$ gjc ralplan --interactive --deliberate "<task description>"',
+		'$ gjc ralplan --write --stage planner --stage_n 1 --artifact "<markdown or path>"',
+	];
 
 	async run(): Promise<void> {
-		const cwd = process.cwd();
-		const result = await runGjcRuntimeBridgeWithHudSidecar("ralplan", this.argv, {
-			cwd,
-			sidecarSkill: "ralplan",
-			onHudPayload: payload =>
-				syncSkillActiveState({
-					cwd,
-					skill: "ralplan",
-					active: payload.active ?? true,
-					phase: payload.phase,
-					sessionId: payload.session_id,
-					threadId: payload.thread_id,
-					turnId: payload.turn_id,
-					hud: payload.hud,
-					source: "gjc-runtime-bridge",
-				}),
-		});
-		if (result.error) process.stderr.write(`${result.error}\n`);
+		const result = await runNativeRalplanCommand(this.argv, process.cwd());
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
 		process.exitCode = result.status;
 	}
 }

package/src/commands/session.ts

@@ -0,0 +1,150 @@
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import {
+	attachGjcTmuxSession,
+	createGjcTmuxSession,
+	listGjcTmuxSessions,
+	removeGjcTmuxSession,
+	statusGjcTmuxSession,
+} from "../gjc-runtime/tmux-sessions";
+
+function writeJson(value: unknown): void {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeText(lines: string[]): void {
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+function writeJsonFailure(error: unknown): void {
+	const message = error instanceof Error ? error.message : String(error);
+	const [reason = "session_error"] = message.split(":");
+	writeJson({ ok: false, reason });
+}
+
+interface SessionJsonDto {
+	name: string;
+	attached: boolean;
+	windows: number;
+	panes: number;
+	bindings: string;
+	createdAt: string;
+}
+
+function sessionJson(session: SessionJsonDto): SessionJsonDto {
+	return {
+		name: session.name,
+		attached: session.attached,
+		windows: session.windows,
+		panes: session.panes,
+		bindings: session.bindings,
+		createdAt: session.createdAt,
+	};
+}
+
+export default class Session extends Command {
+	static description = "List, inspect, attach, and remove tagged GJC-managed tmux sessions";
+	static strict = false;
+
+	static args = {
+		action: Args.string({
+			description: "list (default), status, create, attach, or remove",
+			required: false,
+		}),
+		session: Args.string({
+			description: "Session name for status, attach, or remove",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
+	};
+
+	static examples = [
+		"gjc session list",
+		"gjc session create",
+		"gjc session status <session>",
+		"gjc session attach <session>",
+		"gjc session remove <session>",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Session);
+		const action = args.action ?? "list";
+		const sessionName = args.session;
+		const json = flags.json ?? false;
+		try {
+			if (action === "list") {
+				const sessions = listGjcTmuxSessions();
+				if (json) {
+					writeJson({ ok: true, sessions: sessions.map(sessionJson) });
+					return;
+				}
+				writeText(
+					sessions.map(session =>
+						[
+							session.name,
+							`windows=${session.windows}`,
+							`attached=${session.attached}`,
+							`createdAt=${session.createdAt}`,
+							`panes=${session.panes}`,
+							`bindings=${session.bindings || "none"}`,
+						].join("\t"),
+					),
+				);
+				return;
+			}
+
+			if (action === "create") {
+				const session = createGjcTmuxSession();
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(session) });
+					return;
+				}
+				writeText([`created: ${session.name}`]);
+				return;
+			}
+
+			if (!sessionName) throw new Error("missing_session_name");
+
+			if (action === "status") {
+				const session = statusGjcTmuxSession(sessionName);
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(session) });
+					return;
+				}
+				writeText([
+					`session: ${session.name}`,
+					`windows: ${session.windows}`,
+					`attached: ${session.attached}`,
+					`createdAt: ${session.createdAt}`,
+					`panes: ${session.panes}`,
+					`bindings: ${session.bindings || "none"}`,
+				]);
+				return;
+			}
+
+			if (action === "remove" || action === "rm" || action === "delete") {
+				const removed = removeGjcTmuxSession(sessionName);
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(removed) });
+					return;
+				}
+				writeText([`removed: ${removed.name}`]);
+				return;
+			}
+
+			if (action === "attach") {
+				attachGjcTmuxSession(sessionName);
+				return;
+			}
+			throw new Error(`unknown_session_action:${action}`);
+		} catch (error) {
+			if (json) {
+				writeJsonFailure(error);
+				return;
+			}
+			throw error;
+		}
+	}
+}

package/src/commands/setup.ts

@@ -22,6 +22,7 @@ export default class Setup extends Command {
 		check: Flags.boolean({ char: "c", description: "Check if dependencies are installed" }),
 		force: Flags.boolean({ char: "f", description: "Overwrite existing default workflow skill files" }),
 		json: Flags.boolean({ description: "Output status as JSON" }),
+		preset: Flags.string({ description: "Provider preset: minimax, minimax-cn, or glm" }),
 		compat: Flags.string({ description: "Provider compatibility: openai or anthropic" }),
 		provider: Flags.string({ description: "Provider id to add to models.yml" }),
 		"base-url": Flags.string({ description: "Provider API base URL" }),
@@ -38,6 +39,7 @@ export default class Setup extends Command {
 				json: flags.json,
 				check: flags.check,
 				force: flags.force,
+				preset: flags.preset,
 				compat: flags.compat,
 				provider: flags.provider,
 				baseUrl: flags["base-url"],

package/src/commands/state.ts

@@ -1,12 +1,23 @@
 import { Command } from "@gajae-code/utils/cli";
-import { runBridgedRuntimeEndpoint } from "./gjc-runtime-bridge";
+import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
 
 export default class State extends Command {
-	static description = "Read or update private GJC workflow state";
+	static description = "Read or update GJC workflow state receipts under .gjc/state";
 	static strict = false;
-	static examples = ['$ gjc state read --input \'{"mode":"team"}\' --json'];
+	static examples = [
+		'$ gjc state read --input \'{"mode":"deep-interview"}\' --json',
+		'$ gjc state write --input \'{"state":{"interview_id":"abc"}}\' --mode deep-interview --json',
+		"$ gjc state clear --mode deep-interview",
+		"$ gjc state deep-interview read --json",
+		'$ gjc state ralplan write --input \'{"phase":"approval","active":true}\' --json',
+		"$ gjc state team contract",
+		"$ gjc state deep-interview handoff --to ralplan --json",
+	];
 
 	async run(): Promise<void> {
-		await runBridgedRuntimeEndpoint("state", this.argv);
+		const result = await runNativeStateCommand(this.argv);
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exitCode = result.status;
 	}
 }

package/src/commands/team.ts

@@ -42,6 +42,18 @@ function formatTaskCounts(counts: Record<string, number>): string {
 		.join(" ");
 }
 
+function formatNotificationSummary(snapshot: GjcTeamSnapshot): string {
+	const summary = snapshot.notification_summary;
+	return `notifications: total=${summary.total} replay_eligible=${summary.replay_eligible} pending=${summary.by_state.pending} queued=${summary.by_state.queued} deferred=${summary.by_state.deferred} failed=${summary.by_state.failed}`;
+}
+
+function formatAwaitingIntegrationNextStep(snapshot: GjcTeamSnapshot): string[] {
+	if (snapshot.phase !== "awaiting_integration") return [];
+	return [
+		"next: worker tasks are completed, but integration still needs leader attention before the team is complete",
+	];
+}
+
 function formatIntegrationSummary(snapshot: {
 	integration_by_worker?: Record<string, { status?: string; conflict_files?: string[] }>;
 }): string[] {
@@ -64,7 +76,7 @@ function parseInputFlag(argv: string[]): Record<string, unknown> {
 }
 
 export default class Team extends Command {
-	static description = "Run native GJC tmux team orchestration commands";
+	static description = "Run native GJC tmux team orchestration; --dry-run writes ephemeral .gjc/state/team state only";
 	static strict = false;
 
 	static args = {
@@ -76,13 +88,18 @@ export default class Team extends Command {
 
 	static flags = {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
-		"dry-run": Flags.boolean({ description: "Create team state without starting tmux panes", default: false }),
+		"dry-run": Flags.boolean({
+			description:
+				"Create ephemeral .gjc/state/team state without starting tmux panes; do not commit generated state",
+			default: false,
+		}),
 	};
 
 	static examples = [
 		'gjc team 3:executor "Implement the approved plan"',
 		"gjc team status <team-name> --json",
 		'gjc team api claim-task --input \'{"team_name":"demo","worker_id":"worker-1"}\' --json',
+		'gjc team 2:executor --dry-run --json "Preview state only"',
 		"gjc team shutdown <team-name>",
 	];
 
@@ -118,6 +135,8 @@ export default class Team extends Command {
 				`state: ${snapshot.state_dir}`,
 				`tasks: ${snapshot.task_total} (${formatTaskCounts(snapshot.task_counts)})`,
 				`workers: ${snapshot.workers.map(worker => `${worker.id}:${worker.status}`).join(" ")}`,
+				formatNotificationSummary(snapshot),
+				...formatAwaitingIntegrationNextStep(snapshot),
 				...formatIntegrationSummary(snapshot),
 			]);
 			return;
@@ -141,7 +160,7 @@ export default class Team extends Command {
 			if (!operation || operation === "--help" || operation === "help") {
 				writeText([
 					"Supported operations:",
-					"send-message broadcast mailbox-list mailbox-mark-delivered mailbox-mark-notified",
+					"send-message broadcast mailbox-list mailbox-mark-delivered mailbox-mark-notified notification-list notification-read notification-replay notification-mark-pane-attempt worker-startup-ack",
 					"create-task read-task list-tasks update-task claim-task transition-task-status release-task-claim",
 					"read-config read-manifest read-worker-status read-worker-heartbeat update-worker-heartbeat write-worker-inbox write-worker-identity",
 					"append-event read-events await-event write-shutdown-request read-shutdown-ack read-monitor-snapshot write-monitor-snapshot read-task-approval write-task-approval",
@@ -176,6 +195,7 @@ export default class Team extends Command {
 			`tmux: ${snapshot.tmux_session}`,
 			`state: ${snapshot.state_dir}`,
 			`workers: ${snapshot.workers.length}`,
+			...(dryRun ? ["dry-run: wrote ephemeral .gjc/state/team state only; do not commit generated .gjc state"] : []),
 		]);
 	}
 }

package/src/config/model-registry.ts

@@ -243,6 +243,10 @@ interface ProviderValidationConfig {
 	models: ProviderValidationModel[];
 }
 
+function usesAwsCredentialChain(api: Api | undefined): boolean {
+	return api === "bedrock-converse-stream";
+}
+
 function validateProviderConfiguration(
 	providerName: string,
 	config: ProviderValidationConfig,
@@ -274,10 +278,14 @@ function validateProviderConfiguration(
 		if (!config.baseUrl) {
 			throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
 		}
+		const usesProviderCredentialChain = usesAwsCredentialChain(config.api);
 		const requiresAuth =
 			mode === "runtime-register"
-				? !config.apiKey && !config.oauthConfigured
-				: !config.apiKey && !config.apiKeyEnv && (config.auth ?? "apiKey") !== "none";
+				? !usesProviderCredentialChain && !config.apiKey && !config.oauthConfigured
+				: !usesProviderCredentialChain &&
+					!config.apiKey &&
+					!config.apiKeyEnv &&
+					(config.auth ?? "apiKey") !== "none";
 		if (requiresAuth) {
 			throw new Error(
 				mode === "runtime-register"