@gajae-code/coding-agent 0.12.21 → 0.13.0

package/src/config/provider-selection-policy.ts

@@ -0,0 +1,146 @@
+import type { Api, Model } from "@gajae-code/ai/core";
+
+/**
+ * Effective credential provenance for a provider, derived from credential
+ * surfaces (never from token shape).
+ *
+ * - `"oauth"`: requests are authenticated with an OAuth-provisioned credential,
+ *   including OAuth flows whose access tokens happen to look like API keys
+ *   (e.g. GitHub Copilot `ghu_` tokens).
+ * - `"key"`: a manual or configured API key (stored `api_key`, CLI `--api-key`
+ *   runtime override, `models.yml` `apiKey`/`apiKeyEnv`, or environment key).
+ * - `"keyless"`: no credential is required (local servers, `auth: none`).
+ * - `"unknown"`: no credential surface is present.
+ */
+export type EffectiveProviderAuth = "oauth" | "key" | "keyless" | "unknown";
+
+export interface ProviderSelectionPolicyInput {
+	/** Explicit `modelProviderOrder` from settings; trimmed and case-insensitive. */
+	explicitProviderOrder: readonly string[];
+	/** Effective auth provenance per lowercased provider id. */
+	effectiveAuth: ReadonlyMap<string, EffectiveProviderAuth>;
+	/** Registry catalog provider ids, lowercased, first-wins catalog order. */
+	catalogProviders: readonly string[];
+	/** Registry catalog model selectors ("provider/id"), lowercased, first-wins catalog order. */
+	catalogModels: readonly string[];
+}
+
+export interface ProviderSelectionPolicy {
+	/**
+	 * Total-order rank for a provider: explicit providers `0..n-1`, omitted
+	 * effective-OAuth providers `n`, omitted non-OAuth/unknown/keyless providers
+	 * `n+1`. Unknown providers that were never cataloged still receive the
+	 * non-OAuth rank unless their effective auth is OAuth.
+	 */
+	rank(provider: string): number;
+	/** Lowercased explicit provider ids, in explicit order (deduped). */
+	explicitProviders(): readonly string[];
+	/** Whether a provider was listed explicitly. */
+	isExplicit(provider: string): boolean;
+	/** Ordered distinct provider ids: explicit order first, then catalog order. */
+	orderedProviders(): readonly string[];
+	/** Stable catalog index per lowercased provider id (registry-owned tie data). */
+	providerCatalogIndex(provider: string): number;
+	/** Stable catalog index per lowercased model selector (registry-owned tie data). */
+	modelCatalogIndex(selector: string): number;
+}
+
+/**
+ * Build a pure provider selection policy over explicit user order, effective
+ * credential provenance, and registry-owned catalog tie data. The policy never
+ * reads settings, auth storage, or the model catalog itself — callers pass the
+ * current values in so ranking stays deterministic and testable.
+ */
+export function createProviderSelectionPolicy(input: ProviderSelectionPolicyInput): ProviderSelectionPolicy {
+	const explicitProviders: string[] = [];
+	const explicitSet = new Set<string>();
+	for (const raw of input.explicitProviderOrder) {
+		const normalized = raw.trim().toLowerCase();
+		if (!normalized || explicitSet.has(normalized)) {
+			continue;
+		}
+		explicitSet.add(normalized);
+		explicitProviders.push(normalized);
+	}
+	const explicitCount = explicitProviders.length;
+	const oauthRank = explicitCount;
+	const nonOAuthRank = explicitCount + 1;
+
+	const providerCatalogIndex = new Map<string, number>();
+	const modelCatalogIndex = new Map<string, number>();
+	for (let index = 0; index < input.catalogProviders.length; index += 1) {
+		const provider = input.catalogProviders[index]!;
+		if (!providerCatalogIndex.has(provider)) {
+			providerCatalogIndex.set(provider, index);
+		}
+	}
+	for (let index = 0; index < input.catalogModels.length; index += 1) {
+		const selector = input.catalogModels[index]!;
+		if (!modelCatalogIndex.has(selector)) {
+			modelCatalogIndex.set(selector, index);
+		}
+	}
+
+	const orderedProviders = [...explicitProviders];
+	const seen = new Set(explicitSet);
+	for (const provider of input.catalogProviders) {
+		if (seen.has(provider)) {
+			continue;
+		}
+		seen.add(provider);
+		orderedProviders.push(provider);
+	}
+
+	return {
+		rank(provider: string): number {
+			const normalized = provider.trim().toLowerCase();
+			if (explicitSet.has(normalized)) {
+				return explicitProviders.indexOf(normalized);
+			}
+			return input.effectiveAuth.get(normalized) === "oauth" ? oauthRank : nonOAuthRank;
+		},
+		explicitProviders: () => explicitProviders,
+		isExplicit(provider: string): boolean {
+			return explicitSet.has(provider.trim().toLowerCase());
+		},
+		orderedProviders: () => orderedProviders,
+		providerCatalogIndex(provider: string): number {
+			return providerCatalogIndex.get(provider.trim().toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
+		},
+		modelCatalogIndex(selector: string): number {
+			return modelCatalogIndex.get(selector.trim().toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
+		},
+	};
+}
+
+export interface ProviderSelectionCatalog {
+	/** Lowercased provider ids in first-wins registry catalog order. */
+	readonly catalogProviders: readonly string[];
+	/** Lowercased model selectors in first-wins registry catalog order. */
+	readonly catalogModels: readonly string[];
+}
+
+/**
+ * Derive stable provider/model tie data from the registry catalog order, not
+ * from a caller-supplied candidate array. First occurrence wins so reordering
+ * candidates never changes ranking.
+ */
+export function buildProviderSelectionCatalog(models: readonly Model<Api>[]): ProviderSelectionCatalog {
+	const catalogProviders: string[] = [];
+	const catalogModels: string[] = [];
+	const seenProviders = new Set<string>();
+	const seenModels = new Set<string>();
+	for (const model of models) {
+		const providerKey = model.provider.trim().toLowerCase();
+		if (providerKey && !seenProviders.has(providerKey)) {
+			seenProviders.add(providerKey);
+			catalogProviders.push(providerKey);
+		}
+		const selectorKey = `${model.provider}/${model.id}`.trim().toLowerCase();
+		if (selectorKey && !seenModels.has(selectorKey)) {
+			seenModels.add(selectorKey);
+			catalogModels.push(selectorKey);
+		}
+	}
+	return { catalogProviders, catalogModels };
+}

package/src/config/settings-schema.ts

@@ -522,6 +522,39 @@ export const SETTINGS_SCHEMA = {
 			options: "runtime",
 		},
 	},
+	"modelProfile.proxyProvider": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "model",
+			label: "Proxy Provider",
+			description:
+				"Configured OpenAI-compatible proxy/gateway provider id (e.g. litellm) used by built-in model presets. Leave unset to keep direct provider endpoints.",
+		},
+	},
+	"modelProfile.proxyMode": {
+		type: "enum",
+		values: ["fallback", "always"] as const,
+		default: "fallback",
+		ui: {
+			tab: "model",
+			label: "Proxy Routing Mode",
+			description:
+				"fallback routes only selectors whose direct provider lacks credentials; always routes every proxy-routable built-in preset selector through the configured proxy.",
+			options: [
+				{
+					value: "fallback",
+					label: "Fallback",
+					description: "Use the proxy only when direct provider credentials are unavailable",
+				},
+				{
+					value: "always",
+					label: "Always",
+					description: "Route proxy-routable built-in preset selectors through the proxy",
+				},
+			],
+		},
+	},
 	"session.resumeModelBehavior": {
 		type: "enum",
 		values: ["keepSessionModel", "useCurrentDefault", "ask"] as const,
@@ -541,7 +574,16 @@ export const SETTINGS_SCHEMA = {
 
 	modelTags: { type: "record", default: EMPTY_MODEL_TAGS_RECORD },
 
-	modelProviderOrder: { type: "array", default: EMPTY_STRING_ARRAY },
+	modelProviderOrder: {
+		type: "array",
+		default: EMPTY_STRING_ARRAY,
+		ui: {
+			tab: "providers",
+			label: "Provider Priority Order",
+			description:
+				"Ordered provider priority for automatic model resolution. Providers listed earlier win ties; omitted providers fall back to curated ranking. Unavailable saved entries are retained and skipped at runtime.",
+		},
+	},
 
 	cycleOrder: { type: "array", default: DEFAULT_CYCLE_ORDER },
 
@@ -2079,15 +2121,14 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	// Bounded-memory cold-session offloading (rollout knobs; budgets are fixed
-	// implementation constants in the sidecar primitives, not user-tunable
-	// fields). "shadow" (default) measures and offloads without changing
-	// observable behavior; canary/default-on are release-channel states, not
-	// user-facing enum values.
+	// Bounded-memory cold-session offloading. Budgets are fixed implementation
+	// constants in the sidecar primitives, not user-tunable fields. Auto keeps
+	// ordinary sessions on the eager path and routes transcripts above the eager
+	// admission limit through bounded cold-session state.
 	"sessionMemory.mode": {
 		type: "enum",
-		values: ["off", "shadow", "enabled"] as const,
-		default: "shadow",
+		values: ["off", "shadow", "enabled", "auto"] as const,
+		default: "auto",
 	},
 	// Independent runtime switch for AgentSession's async compact-once overflow
 	// recovery. The synchronous bounded context preflight stays always on.
@@ -3557,74 +3598,6 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
-	"providers.image": {
-		type: "enum",
-		values: ["auto", "openai", "gemini", "openrouter", "antigravity", "alibaba", "custom"] as const,
-		default: "auto",
-		ui: {
-			tab: "providers",
-			label: "Image Generation",
-			description: "Provider and model for image generation tool",
-			options: [
-				{
-					value: "auto",
-					label: "Auto",
-					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini > Alibaba",
-				},
-				{ value: "openai", label: "OpenAI", description: "Uses gpt-image-2 via OpenAI Responses/Codex" },
-				{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
-				{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
-				{ value: "antigravity", label: "Antigravity", description: "Requires login with google-antigravity" },
-				{
-					value: "alibaba",
-					label: "Alibaba Bailian",
-					description: "Requires ALIBABA_TOKEN_PLAN_API_KEY (wan2.7-image via Token Plan)",
-				},
-				{
-					value: "custom",
-					label: "Custom",
-					description: "OpenAI-compatible endpoint (set providers.imageCustomUrl)",
-				},
-			],
-		},
-	},
-	"providers.imageModel": {
-		type: "string",
-		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "Image Model",
-			description: "Override the default image generation model for the selected provider",
-		},
-	},
-	"providers.imageCustomUrl": {
-		type: "string",
-		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "Image Custom URL",
-			description: "Base URL for custom OpenAI-compatible image endpoint",
-		},
-	},
-	"providers.imageCustomKey": {
-		type: "string",
-		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "Image Custom API Key",
-			description: "API key for custom OpenAI-compatible image endpoint",
-		},
-	},
-	"providers.imageCustomKeyEnv": {
-		type: "string",
-		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "Image Custom API Key Env",
-			description: "Environment variable name holding the API key for custom image endpoint",
-		},
-	},
-
 	"providers.kimiApiFormat": {
 		type: "enum",
 		values: ["openai", "anthropic"] as const,
@@ -4174,7 +4147,7 @@ export interface ShellMinimizerSettings {
 }
 
 export interface SessionMemorySettings {
-	mode: "off" | "shadow" | "enabled";
+	mode: "off" | "shadow" | "enabled" | "auto";
 	contextOverflowRecovery: boolean;
 }
 

package/src/config/settings.ts

@@ -810,6 +810,12 @@ export class Settings implements NotificationSettingsReader {
 		this.#rebuildMerged();
 	}
 
+	/** Read the exact runtime override without merged defaults. */
+	getOverride<P extends SettingPath>(path: P): SettingValue<P> | undefined {
+		const value = getByPath(this.#overrides, path.split("."));
+		return value === undefined ? undefined : (value as SettingValue<P>);
+	}
+
 	/**
 	 * Clear a runtime override.
 	 */
@@ -1621,6 +1627,40 @@ export class Settings implements NotificationSettingsReader {
 			}
 		}
 
+		// Migrate legacy providers.image* settings into modelRoles.image.
+		// The image-generation model is now selected via the model-role system
+		// (/model image <selector>) instead of a separate provider config dialog.
+		const providersObj = raw.providers as Record<string, unknown> | undefined;
+		if (providersObj && typeof providersObj.image === "string") {
+			const imageProvider = providersObj.image as string;
+			const imageModel = typeof providersObj.imageModel === "string" ? providersObj.imageModel : undefined;
+			const imageCustomUrl =
+				typeof providersObj.imageCustomUrl === "string" ? providersObj.imageCustomUrl : undefined;
+
+			if (imageProvider !== "auto") {
+				const roles = rawSettingsRecord(raw.modelRoles) ?? {};
+				if (!roles.image) {
+					if (imageProvider === "custom" && imageCustomUrl) {
+						// Custom providers are registered as first-class OpenAI-compatible providers;
+						// the migration produces a provider/model selector.
+						const customProviderId = "image-custom";
+						roles.image = `${customProviderId}/${imageModel ?? "gpt-image-2"}`;
+					} else if (imageModel) {
+						roles.image = `${imageProvider}/${imageModel}`;
+					} else {
+						roles.image = imageProvider;
+					}
+					raw.modelRoles = roles;
+				}
+			}
+
+			delete providersObj.image;
+			delete providersObj.imageModel;
+			delete providersObj.imageCustomUrl;
+			delete providersObj.imageCustomKey;
+			delete providersObj.imageCustomKeyEnv;
+		}
+
 		raw.configSchemaVersion = CONFIG_SCHEMA_VERSION;
 
 		return raw;

package/src/coordinator-mcp/server.ts

@@ -325,6 +325,7 @@ const MISSING_FINAL_RESPONSE_ADVISORY = "completion_missing_final_response";
 const PROMPT_ACK_TIMEOUT_REASON = "runtime_prompt_ack_timeout";
 const DEFAULT_RUNTIME_PROMPT_ACK_TIMEOUT_MS = 10_000;
 const MAX_RUNTIME_PROMPT_ACK_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_COORDINATOR_SESSION_LIST_PAGES = 10_000;
 const ACTIVE_TURN_STATUSES = new Set<TurnStatus>(["delivering", "active", "waiting_for_answer", "completing"]);
 const TERMINAL_TURN_STATUSES = new Set<TurnStatus>(["completed", "failed", "cancelled", "superseded"]);
 const TURN_ID_PATTERN = /^turn-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -3213,6 +3214,34 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		return asRecord(response?.result) ?? response ?? {};
 	}
 
+	async function paginatedBrokerSessionList(
+		cwd: string,
+		input: Record<string, unknown>,
+	): Promise<Record<string, unknown>> {
+		const aggregate: Record<string, unknown> = {};
+		const sessions: unknown[] = [];
+		let cursor: string | undefined;
+		for (let pageCount = 0; pageCount < MAX_COORDINATOR_SESSION_LIST_PAGES; pageCount++) {
+			const page = brokerResult(
+				await brokerSession(cwd, "session.list", {
+					...input,
+					...(cursor === undefined ? {} : { cursor }),
+				}),
+			);
+			for (const [key, value] of Object.entries(page)) {
+				if (key !== "sessions" && key !== "continuationCursor") aggregate[key] = value;
+			}
+			if (Array.isArray(page.sessions)) sessions.push(...page.sessions);
+			const nextCursor =
+				typeof page.continuationCursor === "string" && page.continuationCursor.length > 0
+					? page.continuationCursor
+					: undefined;
+			if (!nextCursor) return { ...aggregate, sessions };
+			cursor = nextCursor;
+		}
+		throw new SdkClientError("protocol_error", "session.list exceeded the page budget.");
+	}
+
 	async function canonicalBrokerWorkspace(cwd: string): Promise<string> {
 		try {
 			return await (services.canonicalizePath ?? (value => fs.realpath(value)))(cwd);
@@ -3259,7 +3288,8 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	};
 
 	async function exactBrokerSessionAuthority(sessionId: string, workspace: string): Promise<BrokerSessionAuthority> {
-		const listing = brokerResult(await brokerSession(workspace, "session.list", { cwd: workspace }));
+		const listing = await paginatedBrokerSessionList(workspace, { cwd: workspace });
+
 		const matches: Array<{ session: Record<string, unknown>; workspace: string }> = [];
 		for (const session of jsonRecords(Array.isArray(listing.sessions) ? listing.sessions : [])) {
 			if (brokerSessionId(session) !== sessionId) continue;
@@ -3410,7 +3440,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		const roots = cwd ? [cwd] : config.allowedRoots;
 		const listings = await Promise.all(
 			roots.map(async root => {
-				const listing = brokerResult(await brokerSession(root, "session.list", { cwd: root }));
+				const listing = await paginatedBrokerSessionList(root, { cwd: root });
 				return scopedBrokerSessions(Array.isArray(listing.sessions) ? listing.sessions : [], root, platform);
 			}),
 		);