@gajae-code/coding-agent 0.15.5 → 0.15.6

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. */
@@ -520,6 +524,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;
     /**

package/dist/types/config/settings-schema.d.ts

@@ -1888,6 +1888,15 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "telemetry.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Anonymous Usage Telemetry";
+            readonly description: "Send minimal allowlisted update and adoption events. Disabled by default; no prompts, paths, environment, identity, or arbitrary errors are collected.";
+        };
+    };
     readonly "starReminder.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/coordinator-mcp/model-preset.d.ts

@@ -2,20 +2,22 @@ export interface CoordinatorModelProfile {
     name: string;
 }
 /**
- * Loads the merged built-in + custom model-profile names from `models.yml`
+ * Loads the merged embedded + accepted registry + custom model-profile names
  * without loading the session-host model registry. The child still owns
  * profile activation; this validates the selection before session creation.
  */
 export type CoordinatorModelProfileLoader = () => Map<string, CoordinatorModelProfile> | Promise<Map<string, CoordinatorModelProfile>>;
 /**
- * Thrown by the default loader when `models.yml` exists but is invalid or
- * unreadable. This lets the resolver fail closed with a distinct, stable reason
- * instead of silently collapsing a broken registry to the built-ins-only set
- * (which would misreport a caller's valid custom profile as unknown).
+ * Thrown by the default loader when `models.yml` or the accepted preset
+ * registry is invalid or unreadable. This lets the resolver fail closed with a
+ * distinct, stable reason instead of silently collapsing a broken registry to
+ * the built-ins-only set (which would misreport a caller's valid custom
+ * profile as unknown).
  */
 export declare class CoordinatorModelProfileRegistryError extends Error {
     constructor(cause?: unknown);
 }
+export declare function createCoordinatorModelProfileLoader(agentDir: string): CoordinatorModelProfileLoader;
 export declare const loadCoordinatorModelProfiles: CoordinatorModelProfileLoader;
 export type CoordinatorMpresetResolution = {
     ok: true;

package/dist/types/coordinator-mcp/projection-scan.d.ts

@@ -0,0 +1,46 @@
+/** Test-only platform seam; production always follows the host platform. */
+export declare const ProjectionScanTestHooks: {
+    platform?: NodeJS.Platform;
+};
+/** Post-filter parse-candidate cap. Exhaustion returns an explicit incomplete result. */
+export declare const COORDINATOR_JSON_SCAN_CAP = 10000;
+export interface ProjectionScanStat {
+    size: number | bigint;
+    dev?: number | bigint;
+    ino?: number | bigint;
+    nlink?: number | bigint;
+    mtimeNs?: number | bigint;
+    ctimeNs?: number | bigint;
+    isDirectory?(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+export interface ProjectionScanFs {
+    readdir(dir: string): Promise<string[]>;
+    lstat(file: string): Promise<ProjectionScanStat>;
+    readFile(file: string, encoding: "utf8", expected?: ProjectionScanStat): Promise<string>;
+    /** Optional descriptor-bound reader used by the production filesystem. */
+    readFileSafe?: (file: string, encoding: "utf8", expected?: ProjectionScanStat) => Promise<string>;
+    /** Optional pinned directory authority used for enumeration and every child operation. */
+    openDirectory?: (dir: string) => Promise<ProjectionScanDirectory>;
+}
+export interface ProjectionScanDirectory {
+    readonly stat: ProjectionScanStat;
+    readdir(): Promise<string[]>;
+    lstat(entry: string): Promise<ProjectionScanStat>;
+    readFile(entry: string, encoding: "utf8", expected?: ProjectionScanStat): Promise<string>;
+    close(): Promise<void>;
+}
+export interface ProjectionScanResult {
+    values: unknown[];
+    parsed: number;
+    capped: boolean;
+    skippedDebris: number;
+    skippedEmpty: number;
+    /** Candidates that changed or disappeared after enumeration. */
+    raced: number;
+    /** True when the scan cannot be authoritative for its caller. */
+    incomplete: boolean;
+}
+export declare function isCoordinatorScanDebrisName(name: string): boolean;
+export declare function listCoordinatorJsonFiles(dir: string, io?: ProjectionScanFs, cap?: number): Promise<ProjectionScanResult>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -344,7 +344,7 @@ export interface ExtensionContext {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
-        sdkRunToken?: string;
+        sdkRunCapability?: unknown;
     }): Promise<unknown>;
     setPlanMode?(on: boolean): unknown;
     operateGoal?(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
@@ -844,8 +844,6 @@ export interface ExtensionAPI {
             startsOwnRun: boolean;
         }) => void;
         preflightSignal?: AbortSignal;
-        /** Internal SDK correlation owner for an exact queued follow-up. */
-        sdkRunToken?: string;
     }): Promise<void>;
     /** Append a custom entry to the session for state persistence (not sent to LLM). */
     appendEntry<T = unknown>(customType: string, data?: T): void;
@@ -1031,8 +1029,6 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
         removed?: boolean;
     }) => void;
     preflightSignal?: AbortSignal;
-    /** Internal SDK correlation owner for an exact queued follow-up. */
-    sdkRunToken?: string;
 }) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
@@ -1169,6 +1165,7 @@ export interface ExtensionContextActions {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
+        sdkRunCapability?: unknown;
     }) => Promise<unknown>;
     setPlanMode?: (on: boolean) => unknown;
     operateGoal?: (op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string) => Promise<unknown>;