@gajae-code/coding-agent 0.15.5 → 0.16.0

package/dist/types/config/file-lock.d.ts

@@ -1,3 +1,5 @@
+import type { NativeDirectoryTreeResult, NativeExactUnlinkResult } from "@gajae-code/natives";
+import { renameDirectoryNoReplacePathAsync, renameNoReplacePathAsync } from "@gajae-code/natives";
 export interface FileLockOptions {
     staleMs?: number;
     retries?: number;
@@ -9,8 +11,16 @@ export interface FileLockOptions {
     /** Previous local host identities accepted only when deciding stale-owner reclamation. */
     previousOwnerHostIds?: readonly string[];
 }
+/** Release retries cover transient Windows/Dropbox handle denial without extending the lock indefinitely. */
+export declare const FILE_LOCK_RELEASE_RETRY_ATTEMPTS = 5;
+export declare const FILE_LOCK_RELEASE_RETRY_DELAY_MS = 10;
 export declare const FileLockTestHooks: {
     afterParentMkdir?: (lockPath: string) => void | Promise<void>;
+    nativePublicationBindings?: () => {
+        renameNoReplacePathAsync: typeof renameNoReplacePathAsync;
+        renameDirectoryNoReplacePathAsync: typeof renameDirectoryNoReplacePathAsync;
+    };
+    nativeQuarantineBindings?: () => NativeFileLockBindings;
 };
 /**
  * Returns the OS-provided process start timestamp for PID-reuse detection.
@@ -25,16 +35,46 @@ export declare const FileLockTestHooks: {
  */
 export declare function processStartTime(pid: number): string | null;
 /** @internal */
+export interface FileLockGcObservation {
+    info: FileLockOwnerToken;
+    bytes: string;
+    identity: GenericFileLockDirIdentity;
+}
+/** Capture owner bytes and the identity proving those exact bytes came from this tree. */
+export declare function readFileLockObservationForGc(lockDir: string): Promise<FileLockGcObservation | null>;
+/** @internal */
 export declare function readFileLockInfoForGc(lockDir: string): Promise<FileLockOwnerToken | null>;
 /** Owner identity stamped into a `<file>.lock/info` record. */
 export interface FileLockOwnerToken {
     pid: number;
     start_time?: string;
+    /** Encoding marker for the canonical UTC process-start identity. */
+    start_time_format?: string;
     owner_host_id?: string;
+    /** Unique acquisition generation, present on locks created by this runtime. */
+    owner_token?: string;
     timestamp: number;
 }
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
-export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
+export type FileLockGcRemoval = "removed" | "owner_changed" | "missing" | "cleanup_failed";
+/** Identity evidence carried by the generic stale verdict into a later removal. */
+export interface GenericFileLockDirIdentity {
+    rootDev: string;
+    rootIno: string;
+    infoDev: string;
+    infoIno: string;
+    infoNlink: string;
+    infoSize: string;
+    infoMtimeNs: string;
+    infoCtimeNs: string;
+    infoSha256: string;
+}
+export type GenericFileLockDirStaleVerdict = {
+    stale: false;
+} | {
+    stale: true;
+    identity: GenericFileLockDirIdentity;
+};
 /**
  * @internal
  * Fail-closed removal of a lock dir whose owner is expected to be dead or
@@ -52,7 +92,7 @@ export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
  * directory, so the residual read->unlink window cannot be fully eliminated,
  * but the reclaim-after-stale scenario the issue describes is now guarded.
  */
-export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken): Promise<FileLockGcRemoval>;
+export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken, preVerdictIdentity?: GenericFileLockDirIdentity): Promise<FileLockGcRemoval>;
 /**
  * @internal
  * READ-ONLY verdict on an EXISTING generic `<file>.lock/` directory that another lock
@@ -71,6 +111,17 @@ export declare function removeFileLockDirForGc(lockDir: string, expected: FileLo
  * the object is no longer the one that was judged.
  */
 export declare function genericFileLockDirIsStale(lockDir: string, staleMs: number, ownerHostId?: string): Promise<boolean>;
+/**
+ * Render a generic stale verdict together with the root and owner-file identity that
+ * verdict actually observed. A caller that removes the directory must require a later
+ * native snapshot to carry this same identity; a snapshot taken only after a clone was
+ * installed is not authority for the stale verdict.
+ */
+export declare function genericFileLockDirStaleVerdict(lockDir: string, staleMs: number, ownerHostId?: string): Promise<GenericFileLockDirStaleVerdict>;
+type NativeFileLockBindings = {
+    snapshotDirectoryTree(lockPath: string): NativeDirectoryTreeResult;
+    exactRemoveDirectoryTree(lockPath: string, snapshot: NonNullable<NativeDirectoryTreeResult["snapshot"]>): NativeExactUnlinkResult;
+};
 /**
  * Serializes all contenders, including callers in the same process. Because this
  * API exposes no ownership token, recursive acquisition is indistinguishable
@@ -78,3 +129,4 @@ export declare function genericFileLockDirIsStale(lockDir: string, staleMs: numb
  * that fact through its own `lockHeld` path instead of acquiring it again.
  */
 export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;
+export {};

package/dist/types/config/internal/model-preset-registry-test-state.d.ts

@@ -0,0 +1,4 @@
+import type { ModelPresetRegistryTrustedKey } from "../model-preset-registry";
+export declare function getModelPresetRegistryTestTrustedKeys(agentDir: string): ReadonlyMap<string, ModelPresetRegistryTrustedKey> | undefined;
+export declare function modelPresetRegistryTestUrlsAllowed(agentDir: string): boolean;
+export declare function runWithModelPresetRegistryTestTrust<T>(agentDir: string, trustedKeys: ReadonlyMap<string, ModelPresetRegistryTrustedKey>, operation: () => T): T;

package/dist/types/config/internal/model-preset-registry-test-support.d.ts

@@ -0,0 +1,3 @@
+import type { ModelPresetRegistryTrustedKey } from "../model-preset-registry";
+/** Runs one test operation with scoped trust. This module is denied by package exports. */
+export declare function withModelPresetRegistryTestTrust<T>(agentDir: string, trustedKeys: ReadonlyMap<string, ModelPresetRegistryTrustedKey>, operation: () => T): T;

package/dist/types/config/keybindings.d.ts

@@ -60,6 +60,7 @@ declare module "@gajae-code/tui" {
 }
 export declare function defaultMessageQueueKeysForPlatform(platform?: NodeJS.Platform): KeyId;
 export declare function defaultClipboardPasteImageKeysForPlatform(platform?: NodeJS.Platform): KeyId[];
+export declare function defaultForegroundFoldKeysForPlatform(platform?: NodeJS.Platform): KeyId[];
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -241,8 +242,8 @@ export declare const KEYBINDINGS: {
         readonly description: "Expand tools";
     };
     readonly "app.tool.backgroundFold": {
-        readonly defaultKeys: "ctrl+b";
-        readonly description: "Fold/background supported foreground tool";
+        readonly defaultKeys: KeyId[];
+        readonly description: "Fold supported foreground tool into a background job";
     };
     readonly "app.editor.external": {
         readonly defaultKeys: "ctrl+g";

package/dist/types/config/model-preset-registry.d.ts

@@ -0,0 +1,368 @@
+import type { Api, Model } from "@gajae-code/ai/core";
+import * as z from "zod/v4";
+import { type ModelProfileDefinition } from "./model-profiles";
+import type { ModelsConfig } from "./models-config-schema";
+export declare const MODEL_PRESET_REGISTRY_CONTRACT_VERSION = "1.0.0";
+export declare const DEFAULT_MODEL_PRESET_REGISTRY_URL = "https://raw.githubusercontent.com/Yeachan-Heo/gajae-code-presets/dev/latest.json";
+export declare const MODEL_PRESET_REGISTRY_REFRESH_INTERVAL_MS: number;
+export declare const MODEL_PRESET_REGISTRY_STARTUP_DELAY_MS = 30000;
+export declare const MODEL_PRESET_REGISTRY_MAX_MANIFEST_BYTES: number;
+export declare const MODEL_PRESET_REGISTRY_MAX_SNAPSHOT_BYTES: number;
+export declare const MODEL_PRESET_REGISTRY_MAX_PROFILES_BYTES: number;
+export declare const MODEL_PRESET_REGISTRY_MAX_PRESETS_BYTES: number;
+export interface ModelPresetRegistryTrustedKey {
+    keyId: string;
+    publicKeyPem: string;
+    validFrom: string;
+    revokedAt?: string;
+}
+export declare const ModelPresetRegistryManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    signed: z.ZodObject<{
+        registryRevision: z.ZodNumber;
+        revision: z.ZodString;
+        publishedAt: z.ZodString;
+        compatibility: z.ZodObject<{
+            consumerContract: z.ZodObject<{
+                minVersion: z.ZodString;
+                maxVersion: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        snapshot: z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strict>;
+        contents: z.ZodObject<{
+            presets: z.ZodObject<{
+                path: z.ZodString;
+                sha256: z.ZodString;
+                bytes: z.ZodNumber;
+                count: z.ZodNumber;
+            }, z.core.$strict>;
+            profiles: z.ZodObject<{
+                path: z.ZodString;
+                sha256: z.ZodString;
+                bytes: z.ZodNumber;
+                count: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        provenance: z.ZodObject<{
+            sourceRepository: z.ZodLiteral<"https://github.com/Yeachan-Heo/gajae-code">;
+            sourceRevision: z.ZodString;
+            sourcePaths: z.ZodArray<z.ZodString>;
+            generatedBy: z.ZodString;
+            generatedAt: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    signature: z.ZodObject<{
+        algorithm: z.ZodLiteral<"Ed25519">;
+        keyId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ModelPresetRegistrySnapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    registryRevision: z.ZodNumber;
+    revision: z.ZodString;
+    compatibility: z.ZodObject<{
+        consumerContract: z.ZodObject<{
+            minVersion: z.ZodString;
+            maxVersion: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    provenance: z.ZodObject<{
+        sourceRepository: z.ZodLiteral<"https://github.com/Yeachan-Heo/gajae-code">;
+        sourceRevision: z.ZodString;
+        sourcePaths: z.ZodArray<z.ZodString>;
+        generatedBy: z.ZodString;
+        generatedAt: z.ZodString;
+    }, z.core.$strict>;
+    contents: z.ZodObject<{
+        presets: z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strict>;
+        profiles: z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ModelPresetRegistryProfilesSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    revision: z.ZodString;
+    dynamicProviders: z.ZodArray<z.ZodString>;
+    profiles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        providerGroup: z.ZodString;
+        requiredProviders: z.ZodArray<z.ZodString>;
+        alternativeProviderGroups: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+        roleBindings: z.ZodObject<{
+            default: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            executor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            architect: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            planner: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            critic: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ModelPresetRegistryPresetsSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    revision: z.ZodString;
+    presets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        name: z.ZodString;
+        api: z.ZodEnum<{
+            "anthropic-messages": "anthropic-messages";
+            "azure-openai-responses": "azure-openai-responses";
+            "bedrock-converse-stream": "bedrock-converse-stream";
+            "cursor-agent": "cursor-agent";
+            "google-gemini-cli": "google-gemini-cli";
+            "google-generative-ai": "google-generative-ai";
+            "google-vertex": "google-vertex";
+            "ollama-chat": "ollama-chat";
+            "openai-codex-responses": "openai-codex-responses";
+            "openai-completions": "openai-completions";
+            "openai-responses": "openai-responses";
+        }>;
+        reasoning: z.ZodBoolean;
+        input: z.ZodArray<z.ZodEnum<{
+            image: "image";
+            text: "text";
+        }>>;
+        output: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            image: "image";
+            text: "text";
+        }>>>;
+        cost: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+        }, z.core.$strict>;
+        contextWindow: z.ZodNumber;
+        maxTokens: z.ZodNumber;
+        compat: z.ZodOptional<z.ZodObject<{
+            maxTokensField: z.ZodOptional<z.ZodLiteral<"max_tokens">>;
+            reasoningContentField: z.ZodOptional<z.ZodLiteral<"reasoning_content">>;
+            thinkingFormat: z.ZodOptional<z.ZodLiteral<"zai">>;
+            reasoningEffortMap: z.ZodOptional<z.ZodObject<{
+                minimal: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+                low: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+                medium: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+                high: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+                xhigh: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+                max: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>>;
+            requiresAssistantContentForToolCalls: z.ZodOptional<z.ZodBoolean>;
+            requiresReasoningContentForToolCalls: z.ZodOptional<z.ZodBoolean>;
+            supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+            supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
+            supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
+            supportsStore: z.ZodOptional<z.ZodBoolean>;
+            supportsToolChoice: z.ZodOptional<z.ZodBoolean>;
+            supportsUsageInStreaming: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                "anthropic-adaptive": "anthropic-adaptive";
+                "anthropic-budget-effort": "anthropic-budget-effort";
+                budget: "budget";
+                effort: "effort";
+                "google-level": "google-level";
+            }>;
+            minLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                xhigh: "xhigh";
+            }>>;
+            maxLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                xhigh: "xhigh";
+            }>>;
+            defaultLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                xhigh: "xhigh";
+            }>>;
+            levels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                xhigh: "xhigh";
+            }>>>;
+        }, z.core.$strict>>;
+        longContextPricing: z.ZodOptional<z.ZodObject<{
+            threshold: z.ZodNumber;
+            cost: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        applyPatchToolType: z.ZodOptional<z.ZodLiteral<"freeform">>;
+        preferWebsockets: z.ZodOptional<z.ZodBoolean>;
+        premiumMultiplier: z.ZodOptional<z.ZodNumber>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        contextPromotionTarget: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ModelPresetRegistryManifest = z.infer<typeof ModelPresetRegistryManifestSchema>;
+export type ModelPresetRegistrySnapshot = z.infer<typeof ModelPresetRegistrySnapshotSchema>;
+export type ModelPresetRegistryProfiles = z.infer<typeof ModelPresetRegistryProfilesSchema>;
+export type ModelPresetRegistryPresets = z.infer<typeof ModelPresetRegistryPresetsSchema>;
+export interface ModelPresetRegistryDependencies {
+    agentDir?: string;
+    manifestUrl?: string;
+    fetch?: typeof fetch;
+    now?: () => Date;
+    timeoutMs?: number;
+    maxManifestBytes?: number;
+    maxSnapshotBytes?: number;
+    maxProfilesBytes?: number;
+    maxPresetsBytes?: number;
+    maxStateBytes?: number;
+    automaticRefresh?: boolean;
+    startupDelayMs?: number;
+    refreshIntervalMs?: number;
+    knownManifestSha256?: string;
+}
+export interface AcceptedModelPresetRegistry {
+    profiles: Map<string, ModelProfileDefinition>;
+    presets: Model<Api>[];
+    dynamicProviders: string[];
+    revision?: number;
+    revisionId?: string;
+    manifestSha256?: string;
+    keyId?: string;
+    sourceRevision?: string;
+    retainedProfiles: string[];
+    retainedPresets: string[];
+    error?: string;
+    disabled: boolean;
+    pinnedRevision?: number;
+}
+export type ModelPresetRegistryRefreshResult = {
+    status: "updated";
+    revision: number;
+    revisionId: string;
+    manifestSha256: string;
+    retainedProfiles: string[];
+    retainedPresets: string[];
+} | {
+    status: "not_modified";
+    revision?: number;
+} | {
+    status: "disabled";
+    revision?: number;
+};
+export interface ModelPresetRegistryStatus {
+    contractVersion: string;
+    source: "embedded" | "registry";
+    cacheHealth: "empty" | "valid" | "corrupt";
+    activeRevision?: number;
+    activeRevisionId?: string;
+    highestSeenRevision?: number;
+    manifestSha256?: string;
+    snapshotSha256?: string;
+    profilesSha256?: string;
+    presetsSha256?: string;
+    keyId?: string;
+    sourceRevision?: string;
+    acceptedAt?: string;
+    publishedAt?: string;
+    lastCheckedAt?: string;
+    lastError?: string;
+    disabled: boolean;
+    pinnedRevision?: number;
+    retainedProfiles: string[];
+    retainedPresets: string[];
+    historyRevisions: number[];
+    profileCount: number;
+    presetCount: number;
+}
+export declare function canonicalModelPresetRegistryJson(value: unknown): string;
+export declare function loadAcceptedModelPresetRegistry(agentDir?: string, dependencies?: Omit<ModelPresetRegistryDependencies, "agentDir">): AcceptedModelPresetRegistry;
+/**
+ * Async accepted-registry loader for validation paths that can await disk I/O.
+ * It mirrors the synchronous loader's fail-closed result contract while using
+ * Bun file reads for state/control payloads.
+ */
+export declare function loadAcceptedModelPresetRegistryAsync(agentDir?: string, dependencies?: Omit<ModelPresetRegistryDependencies, "agentDir">): Promise<AcceptedModelPresetRegistry>;
+export declare function loadAcceptedModelPresetProfiles(agentDir?: string, dependencies?: Omit<ModelPresetRegistryDependencies, "agentDir">): AcceptedModelPresetRegistry;
+export declare function loadEffectiveModelProfiles(userProfiles: ModelsConfig["profiles"] | undefined, agentDir?: string, dependencies?: Omit<ModelPresetRegistryDependencies, "agentDir">): Map<string, ModelProfileDefinition>;
+export declare function refreshModelPresetRegistry(dependencies?: ModelPresetRegistryDependencies): Promise<ModelPresetRegistryRefreshResult>;
+export declare function setModelPresetRegistryDisabled(options: ModelPresetRegistryDependencies & {
+    disabled: boolean;
+}): Promise<void>;
+export declare function setModelPresetRegistryPin(options: ModelPresetRegistryDependencies & {
+    revision?: number;
+}): Promise<void>;
+export declare function rollbackModelPresetRegistry(options: ModelPresetRegistryDependencies & {
+    revision?: number;
+}): Promise<void>;
+export declare function getModelPresetRegistryStatus(dependencies?: ModelPresetRegistryDependencies): ModelPresetRegistryStatus;
+export declare function refreshModelPresetRegistryInBackground(dependencies?: ModelPresetRegistryDependencies, onAccepted?: () => void): () => Promise<void>;

package/dist/types/config/model-profile-activation.d.ts

@@ -1,6 +1,7 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, Model } from "@gajae-code/ai/core";
 import type { AgentSession, DefaultFallbackRuntimeState } from "../session/agent-session";
+import { type ModelProfileDefinition } from "./model-profiles";
 export { resolveModelProfileName } from "./model-profile-contract";
 import { type GjcModelAssignmentTargetId, type ModelRegistry } from "./model-registry";
 import { type ModelSelectorValue } from "./model-selector-value";
@@ -129,6 +130,44 @@ export declare class ModelProfileCredentialError extends Error {
     constructor(profileLabel: string, providers: readonly string[], role?: string);
 }
 export declare function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string;
+/**
+ * Resolve the explicitly configured OpenAI-compatible proxy provider id for a
+ * preset. Returns undefined when unset or empty. Passwords/labels are never
+ * treated as proxy ids here; only lowercase provider ids from settings.
+ */
+export declare function resolveProxyProviderId(settings: Pick<Settings, "get"> | undefined): string | undefined;
+export type ProxyProviderConfig = {
+    status: "unset";
+} | {
+    status: "configured";
+    id: string;
+} | {
+    status: "invalid";
+    value: string;
+};
+export declare function inspectProxyProviderId(settings: Pick<Settings, "get"> | undefined): ProxyProviderConfig;
+/** Passive surfaces fail closed on malformed settings instead of throwing. */
+export declare function tryResolveProxyProviderId(settings: Pick<Settings, "get"> | undefined): string | undefined;
+export type ModelProfileProxyMode = "fallback" | "always";
+export declare function resolveProxyMode(settings: Pick<Settings, "get"> | undefined): ModelProfileProxyMode;
+/**
+ * Rewrite a qualified provider selector so its model is served through the
+ * configured proxy. The proxy catalog uses sub-provider-prefixed model ids
+ * (e.g. `xiaomi/mimo-v2.5-pro` under `litellm`). Exact provider-prefixed
+ * matches win; a unique final-segment match is accepted for gateways that do
+ * not retain the upstream provider prefix. Missing or ambiguous matches fail
+ * closed rather than leaving an unauthenticated role selector behind.
+ */
+export declare function getProxyRoutableProviders(profile: ModelProfileDefinition): ReadonlySet<string>;
+/**
+ * Profile sources whose non-default qualified role bindings are part of the
+ * activation contract. Proxy rewrites run before role resolution, so a
+ * rewritten selector satisfies this prerequisite when its concrete proxy
+ * model is present in the effective catalog. Embedded built-ins intentionally
+ * retain their legacy tolerance for stale qualified role tails.
+ */
+export declare function requiresQualifiedModelProfileRoleResolution(profile: Pick<ModelProfileDefinition, "source">): boolean;
+export declare function rewriteSelectorForProxy(selector: string, proxyProvider: string, proxyMode: ModelProfileProxyMode, allModels: Model<Api>[], directlyAuthenticated: ReadonlySet<string>, routableProviders: ReadonlySet<string>): string;
 export declare function prepareModelProfileActivation(options: PrepareModelProfileActivationOptions): Promise<PreparedModelProfileActivation>;
 export declare function applyPreparedModelProfileActivation(prepared: PreparedModelProfileActivation, options?: ApplyModelProfileActivationOptions): Promise<void>;
 export interface MaterializeModelProfileForDeletionResult {

package/dist/types/config/model-profiles.d.ts

@@ -5,6 +5,7 @@ export interface ModelProfileDefinition {
     name: string;
     requiredProviders: string[];
     displayName?: string;
+    providerGroup?: string;
     /**
      * Optional groups of providers that are interchangeable fallbacks.
      * Each group is an array of provider ids where at least one must be
@@ -16,7 +17,7 @@ export interface ModelProfileDefinition {
      */
     alternativeProviderGroups?: readonly (readonly string[])[];
     modelMapping: Partial<Record<ModelProfileRole, ModelSelectorValue>>;
-    source: "builtin" | "user";
+    source: "builtin" | "registry" | "user";
 }
 export interface ResolvedProfileBinding {
     defaultSelector?: ModelSelectorValue;
@@ -45,10 +46,11 @@ export interface ModelProfilePresentation {
     displayName: string;
     providerGroup: string;
 }
-export declare function getModelProfilePresentation(profile: string | Pick<ModelProfileDefinition, "name" | "displayName">): ModelProfilePresentation;
+export declare function getModelProfilePresentation(profile: string | Pick<ModelProfileDefinition, "name" | "displayName" | "providerGroup">): ModelProfilePresentation;
 export declare function formatModelProfileDisplayLabel(profile: Pick<ModelProfileDefinition, "name" | "displayName">): string;
 export declare function groupModelProfilesForPresetLanding(profiles: ReadonlyMap<string, ModelProfileDefinition>): Map<string, ModelProfileDefinition[]>;
 export declare function recommendModelProfileForProvider(providerId: string, profiles: ReadonlyMap<string, ModelProfileDefinition>): ModelProfileDefinition | undefined;
-export declare function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map<string, ModelProfileDefinition>;
+export type RegistryModelProfilesInput = ReadonlyMap<string, ModelProfileDefinition> | readonly ModelProfileDefinition[] | Readonly<Record<string, ModelProfileDefinition>>;
+export declare function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"], registryProfiles?: RegistryModelProfilesInput): Map<string, ModelProfileDefinition>;
 export declare function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding;
 export declare function formatAvailableProfileNames(profiles: ReadonlyMap<string, ModelProfileDefinition>): string;

package/dist/types/config/model-registry.d.ts

@@ -4,10 +4,11 @@ import { type ThemeColor } from "../modes/theme/theme";
 import { type ActiveProviderDescriptor } from "../sdk/providers";
 import type { AuthStorage } from "../session/auth-storage";
 import type { ActiveSearchModelContext, WebSearchMode } from "../web/search/types";
-import { type ConfigError, ConfigFile } from "./config-file";
+import { ConfigError, ConfigFile } from "./config-file";
 import { isAuthenticated, kNoAuth } from "./model-auth";
 import { type ConfiguredModelBindings } from "./model-bindings-applier";
 import { type ProviderDiscoveryState } from "./model-discovery-manager";
+import { type ModelPresetRegistryDependencies } from "./model-preset-registry";
 export type { ProviderDiscoveryState, ProviderDiscoveryStatus } from "./model-discovery-manager";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
 import { type ModelProfileDefinition } from "./model-profiles";
@@ -301,6 +302,7 @@ export declare const ModelsConfigFile: ConfigFile<{
 }>;
 /** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */
 interface ProviderOverride {
+    api?: Api;
     baseUrl?: string;
     headers?: Record<string, string>;
     apiKey?: string;
@@ -309,6 +311,7 @@ interface ProviderOverride {
     transport?: Model<Api>["transport"];
     requestTransform?: ModelRequestTransform;
     cacheRetention?: CacheRetention;
+    isOAuth?: boolean;
 }
 /**
  * Merge a freshly discovered model with the matching bundled/configured entry
@@ -349,12 +352,13 @@ export declare class ModelRegistry {
     /**
      * @param authStorage - Auth storage for API key resolution
      */
-    constructor(authStorage: AuthStorage, modelsPath?: string, registrySettings?: Pick<Settings, "get" | "getGlobal">);
+    constructor(authStorage: AuthStorage, modelsPath?: string, registrySettings?: Pick<Settings, "get" | "getGlobal">, modelPresetRegistryDependencies?: ModelPresetRegistryDependencies);
+    dispose(): Promise<void>;
     onCatalogChanged(listener: () => void): () => void;
     /** Replace the read-only settings snapshot used by profile-scoped resolution. */
     setScopedSettings(settingsReader: Pick<Settings, "get" | "getGlobal">): void;
     /**
-     * Reload models from disk (built-in + custom from models.json).
+     * Reload models from disk (embedded + accepted registry + custom from models.yml).
      */
     refresh(strategy?: ModelRefreshStrategy): Promise<void>;
     refreshInBackground(strategy?: ModelRefreshStrategy): void;
@@ -384,8 +388,8 @@ export declare class ModelRegistry {
     /** The currently configured modelBindings, for pre-profile baseline lookup. */
     getConfiguredModelBindings(): ConfiguredModelBindings | undefined;
     /**
-     * Get all models (built-in + custom).
-     * If models.json had errors, returns only built-in models.
+     * Get all models (embedded + accepted registry + custom).
+     * If models.yml had errors, returns embedded plus accepted registry models.
      */
     getAll(): Model<Api>[];
     /** Provider ids declared in models.yml, including override-only providers. */
@@ -405,6 +409,12 @@ export declare class ModelRegistry {
      * with case-sensitive exact strings.
      */
     autoroutingProviderOrder(): readonly string[];
+    /**
+     * Provider priority for automatic model selection. Explicit provider order
+     * wins first, followed by omitted OAuth providers, then other providers;
+     * catalog order breaks ties within each policy band.
+     */
+    automaticProviderOrder(sessionId?: string): readonly string[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
     /**
      * Batch form of {@link resolveCanonicalModel} over every canonical record:
@@ -520,6 +530,8 @@ export declare class ModelRegistry {
      * Get the base URL associated with a provider, if any model defines one.
      */
     getProviderBaseUrl(provider: string): string | undefined;
+    /** Opaque owner token for registry-scoped AuthStorage reads. */
+    getAuthStorageOwner(): object;
     getProviderWebSearchMode(provider: string): WebSearchMode | undefined;
     getActiveSearchModelContext(model: Model<Api>): ActiveSearchModelContext;
     /**