@hasna/switcher 0.1.2 → 0.1.4

package/dist/cli.d.ts

@@ -1,2 +1,4 @@
 #!/usr/bin/env bun
+import { type ModelPolicy } from "./domain";
+export declare function readModelPolicy(file: string | undefined, roleValues: string[] | undefined): Promise<ModelPolicy | undefined>;
 export declare function main(args?: string[]): Promise<void>;

package/dist/codex-model-policy.d.ts

@@ -0,0 +1,65 @@
+import { type ModelPolicy } from "./model-policy-schema";
+type Dict = Record<string, unknown>;
+/** Keys which can redirect a Codex request outside Switcher's launch provider. */
+export declare const codexRoutingKeys: Set<string>;
+export declare const codexTransportKeys: Set<string>;
+export type CodexAgentInput = {
+    description?: string;
+    config_file?: string;
+    nickname_candidates?: string[];
+    /** Parsed contents of config_file. The caller reads native config layers. */
+    config?: Dict;
+    trusted?: boolean;
+};
+export type CodexModelPolicyInput = {
+    model: string;
+    policy?: ModelPolicy;
+    /** Effective native global/project config, after Codex precedence is applied. */
+    effectiveConfig?: Dict;
+    agents?: Record<string, CodexAgentInput>;
+    switcherProvider: string;
+    switcherBaseUrl: string;
+    /** Project config is never activated unless the caller has established trust. */
+    trustedProject?: boolean;
+};
+export type CodexAgentOverride = {
+    name: string;
+    model: string;
+    config: Dict;
+    sourceConfigFile?: string;
+    trusted: boolean;
+};
+export type CodexModelPolicyResult = {
+    model: string;
+    subagentModel: string;
+    reviewModel: string;
+    provider: {
+        name: string;
+        base_url: string;
+    };
+    /** Structured -c values; the launcher serializes these as TOML. */
+    overrides: Record<string, unknown>;
+    agents: CodexAgentOverride[];
+    ignoredUntrustedAgents: string[];
+};
+/** Extract named role declarations from an already merged native config layer. */
+export declare function codexAgentsFromEffectiveConfig(config: Dict, trustedProject?: boolean, baseDir?: string): Record<string, CodexAgentInput>;
+/** Compile only routing controls; native instructions, permissions and descriptions remain intact. */
+export declare function compileCodexModelPolicy(input: CodexModelPolicyInput): CodexModelPolicyResult;
+/** Small deterministic TOML writer for the copied, sanitized agent config layer. */
+export declare function renderCodexAgentToml(config: Dict): string;
+/** Copy sanitized role layers into the per-launch state directory. */
+export declare function writeCodexAgentOverrides(result: CodexModelPolicyResult, stateDir: string): Promise<Record<string, string>>;
+export type PrepareCodexModelPolicyInput = Omit<CodexModelPolicyInput, "effectiveConfig" | "agents"> & {
+    cwd: string;
+    stateDir: string;
+    home?: string;
+};
+/** Load global Codex config plus trusted .codex/config.toml ancestors, then prepare role layers. */
+export declare function prepareCodexModelPolicy(input: PrepareCodexModelPolicyInput): Promise<CodexModelPolicyResult & {
+    agentConfigPaths: Record<string, string>;
+    configPaths: string[];
+}>;
+/** Read a referenced role layer without activating it; callers must establish project trust. */
+export declare function readCodexAgentConfig(path: string): Promise<Dict>;
+export {};

package/dist/credentials.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type CredentialChainOptions } from "@hasna/contracts/client";
 import { CommandInterrupted, type ProviderInput } from "./domain";
 declare const keychain: z.ZodObject<{
     kind: z.ZodLiteral<"keychain">;
@@ -13,7 +14,7 @@ declare const keychain: z.ZodObject<{
     service: string;
     account: string;
 }>;
-export declare const credentialBindingSchema: z.ZodObject<{
+export declare const credentialBindingSchema: z.ZodEffects<z.ZodObject<{
     schema: z.ZodLiteral<1>;
     credentialEnv: z.ZodString;
     origins: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
@@ -32,9 +33,15 @@ export declare const credentialBindingSchema: z.ZodObject<{
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"vault">;
         key: z.ZodString;
-        url: z.ZodEffects<z.ZodString, string, string>;
+        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
         executable: z.ZodEffects<z.ZodString, string, string>;
         operator: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"contracts">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "contracts";
+        }, {
+            kind: "contracts";
+        }>, z.ZodObject<{
             kind: z.ZodLiteral<"env">;
         }, "strict", z.ZodTypeAny, {
             kind: "env";
@@ -42,7 +49,7 @@ export declare const credentialBindingSchema: z.ZodObject<{
             kind: "env";
         }>, z.ZodObject<{
             kind: z.ZodLiteral<"keychain">;
-            account: z.ZodString;
+            account: z.ZodEffects<z.ZodString, string, string>;
         }, "strict", z.ZodTypeAny, {
             kind: "keychain";
             account: string;
@@ -51,27 +58,31 @@ export declare const credentialBindingSchema: z.ZodObject<{
             account: string;
         }>]>;
     }, "strict", z.ZodTypeAny, {
-        url: string;
         key: string;
         executable: string;
         kind: "vault";
         operator: {
+            kind: "contracts";
+        } | {
             kind: "env";
         } | {
             kind: "keychain";
             account: string;
         };
+        url?: string | undefined;
     }, {
-        url: string;
         key: string;
         executable: string;
         kind: "vault";
         operator: {
+            kind: "contracts";
+        } | {
             kind: "env";
         } | {
             kind: "keychain";
             account: string;
         };
+        url?: string | undefined;
     }>]>;
 }, "strict", z.ZodTypeAny, {
     credentialEnv: string;
@@ -80,16 +91,18 @@ export declare const credentialBindingSchema: z.ZodObject<{
         service: string;
         account: string;
     } | {
-        url: string;
         key: string;
         executable: string;
         kind: "vault";
         operator: {
+            kind: "contracts";
+        } | {
             kind: "env";
         } | {
             kind: "keychain";
             account: string;
         };
+        url?: string | undefined;
     };
     schema: 1;
     origins: string[];
@@ -100,16 +113,62 @@ export declare const credentialBindingSchema: z.ZodObject<{
         service: string;
         account: string;
     } | {
-        url: string;
         key: string;
         executable: string;
         kind: "vault";
         operator: {
+            kind: "contracts";
+        } | {
             kind: "env";
         } | {
             kind: "keychain";
             account: string;
         };
+        url?: string | undefined;
+    };
+    schema: 1;
+    origins: string[];
+}>, {
+    credentialEnv: string;
+    source: {
+        kind: "keychain";
+        service: string;
+        account: string;
+    } | {
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "contracts";
+        } | {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+        url?: string | undefined;
+    };
+    schema: 1;
+    origins: string[];
+}, {
+    credentialEnv: string;
+    source: {
+        kind: "keychain";
+        service: string;
+        account: string;
+    } | {
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "contracts";
+        } | {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+        url?: string | undefined;
     };
     schema: 1;
     origins: string[];
@@ -130,16 +189,18 @@ export declare class CredentialBindings {
             service: string;
             account: string;
         } | {
-            url: string;
             key: string;
             executable: string;
             kind: "vault";
             operator: {
+                kind: "contracts";
+            } | {
                 kind: "env";
             } | {
                 kind: "keychain";
                 account: string;
             };
+            url?: string | undefined;
         };
         schema: 1;
         origins: string[];
@@ -173,6 +234,8 @@ export declare class CredentialResolver {
 export declare class CredentialInterrupted extends CommandInterrupted {
     constructor(exitCode: number);
 }
+/** Select an operator through the shared credential seam, then pin that choice. */
+export declare function vaultEnvironment(binding: CredentialBinding, env: NodeJS.ProcessEnv, options?: Pick<CredentialChainOptions, "keychain">): Promise<NodeJS.ProcessEnv>;
 /** Internal child mode: the key travels only through an authenticated loopback request. */
 export declare function deliverVaultCredential(): Promise<void>;
 export {};

package/dist/direct-launch.d.ts

@@ -1,6 +1,6 @@
 import { SwitcherClient, type Provider, type Profile } from "./sdk";
-import { type Model } from "./domain";
+import { type Model, type ModelPolicy } from "./domain";
 import { type PresetOptions } from "./presets";
 export declare function resolveLaunchProvider(client: SwitcherClient, selector: string, options?: PresetOptions): Promise<Provider>;
 export declare function selectModel(models: Model[], query?: string, harness?: Profile["harness"]): Promise<string>;
-export declare function ensureLaunchProfile(client: SwitcherClient, provider: Provider, harness: Profile["harness"], model: string): Promise<Profile>;
+export declare function ensureLaunchProfile(client: SwitcherClient, provider: Provider, harness: Profile["harness"], model: string, modelPolicy?: ModelPolicy): Promise<Profile>;

package/dist/domain.d.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
+import { type RoutingEvent } from "./model-policy-schema";
+export { modelPolicySchema, routingEventSchema, routingEventsSchema } from "./model-policy-schema";
+export type { ModelPolicy, RoutingEvent } from "./model-policy-schema";
 export type { AuthStyle } from "./auth";
-export declare const VERSION = "0.1.2";
+export declare const VERSION = "0.1.4";
 export declare const harnessSchema: z.ZodEnum<["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]>;
 export declare const protocolSchema: z.ZodEnum<["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]>;
 export declare const idSchema: z.ZodString;
@@ -264,44 +267,295 @@ export declare const profileInputSchema: z.ZodObject<{
     providerId: z.ZodString;
     harness: z.ZodEnum<["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]>;
     model: z.ZodString;
+    modelPolicy: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodLiteral<1>>;
+        roles: z.ZodOptional<z.ZodObject<{
+            subagent: z.ZodOptional<z.ZodString>;
+            fast: z.ZodOptional<z.ZodString>;
+            planning: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+            compaction: z.ZodOptional<z.ZodString>;
+            weak: z.ZodOptional<z.ZodString>;
+            editor: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        }, {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        }>>;
+        allowedModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        aliases: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodString>, Record<string, string>, Record<string, string>>>;
+        fallbacks: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>, Record<string, string[]>, Record<string, string[]>>>;
+    }, "strict", z.ZodTypeAny, {
+        version: 1;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    }, {
+        version?: 1 | undefined;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     name: string;
     providerId: string;
     harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
+    modelPolicy?: {
+        version: 1;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    } | undefined;
 }, {
     id: string;
     name: string;
     providerId: string;
     harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
+    modelPolicy?: {
+        version?: 1 | undefined;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    } | undefined;
 }>;
 export declare const runInputSchema: z.ZodObject<{
+    modelPolicyVersion: z.ZodLiteral<1>;
     profileId: z.ZodString;
     harness: z.ZodEnum<["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]>;
     model: z.ZodString;
+    modelPolicy: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodLiteral<1>>;
+        roles: z.ZodOptional<z.ZodObject<{
+            subagent: z.ZodOptional<z.ZodString>;
+            fast: z.ZodOptional<z.ZodString>;
+            planning: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+            compaction: z.ZodOptional<z.ZodString>;
+            weak: z.ZodOptional<z.ZodString>;
+            editor: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        }, {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        }>>;
+        allowedModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        aliases: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodString>, Record<string, string>, Record<string, string>>>;
+        fallbacks: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>, Record<string, string[]>, Record<string, string[]>>>;
+    }, "strict", z.ZodTypeAny, {
+        version: 1;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    }, {
+        version?: 1 | undefined;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    }>>;
     planToken: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
+    modelPolicyVersion: 1;
     profileId: string;
     planToken: string;
+    modelPolicy?: {
+        version: 1;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    } | undefined;
 }, {
     harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
+    modelPolicyVersion: 1;
     profileId: string;
     planToken: string;
+    modelPolicy?: {
+        version?: 1 | undefined;
+        roles?: {
+            subagent?: string | undefined;
+            fast?: string | undefined;
+            planning?: string | undefined;
+            review?: string | undefined;
+            summary?: string | undefined;
+            compaction?: string | undefined;
+            weak?: string | undefined;
+            editor?: string | undefined;
+        } | undefined;
+        allowedModels?: string[] | undefined;
+        aliases?: Record<string, string> | undefined;
+        fallbacks?: Record<string, string[]> | undefined;
+    } | undefined;
 }>;
 export declare const runUpdateSchema: z.ZodObject<{
     status: z.ZodEnum<["exited", "failed", "interrupted"]>;
     exitCode: z.ZodNumber;
+    routingEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        requestId: z.ZodString;
+        requestedModel: z.ZodString;
+        resolvedModel: z.ZodOptional<z.ZodString>;
+        reportedModel: z.ZodOptional<z.ZodString>;
+        decision: z.ZodEnum<["allow", "alias", "reject", "fallback"]>;
+        role: z.ZodOptional<z.ZodEnum<["main", "subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]>>;
+        reason: z.ZodOptional<z.ZodString>;
+        upstreamStatus: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        at: string;
+        requestId: string;
+        requestedModel: string;
+        decision: "allow" | "alias" | "reject" | "fallback";
+        resolvedModel?: string | undefined;
+        reportedModel?: string | undefined;
+        role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+        reason?: string | undefined;
+        upstreamStatus?: number | undefined;
+    }, {
+        at: string;
+        requestId: string;
+        requestedModel: string;
+        decision: "allow" | "alias" | "reject" | "fallback";
+        resolvedModel?: string | undefined;
+        reportedModel?: string | undefined;
+        role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+        reason?: string | undefined;
+        upstreamStatus?: number | undefined;
+    }>, "many">>;
+    routingEventsDropped: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     status: "exited" | "failed" | "interrupted";
     exitCode: number;
+    routingEvents?: {
+        at: string;
+        requestId: string;
+        requestedModel: string;
+        decision: "allow" | "alias" | "reject" | "fallback";
+        resolvedModel?: string | undefined;
+        reportedModel?: string | undefined;
+        role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+        reason?: string | undefined;
+        upstreamStatus?: number | undefined;
+    }[] | undefined;
+    routingEventsDropped?: number | undefined;
 }, {
     status: "exited" | "failed" | "interrupted";
     exitCode: number;
+    routingEvents?: {
+        at: string;
+        requestId: string;
+        requestedModel: string;
+        decision: "allow" | "alias" | "reject" | "fallback";
+        resolvedModel?: string | undefined;
+        reportedModel?: string | undefined;
+        role?: "main" | "subagent" | "fast" | "planning" | "review" | "summary" | "compaction" | "weak" | "editor" | undefined;
+        reason?: string | undefined;
+        upstreamStatus?: number | undefined;
+    }[] | undefined;
+    routingEventsDropped?: number | undefined;
 }>;
 export type ProviderInput = z.input<typeof providerInputSchema>;
 export type Provider = z.output<typeof providerInputSchema> & {
@@ -314,7 +568,8 @@ export type Profile = ProfileInput & {
     updatedAt: string;
 };
 export type Model = z.infer<typeof modelSchema>;
-export type Run = z.infer<typeof runInputSchema> & {
+export type Run = Omit<z.infer<typeof runInputSchema>, "modelPolicyVersion"> & {
+    modelPolicyVersion?: 1;
     providerId: string;
     providerVersion: number;
     profileVersion: number;
@@ -323,6 +578,8 @@ export type Run = z.infer<typeof runInputSchema> & {
     startedAt: string;
     endedAt?: string;
     exitCode?: number;
+    routingEvents?: RoutingEvent[];
+    routingEventsDropped?: number;
     version: number;
     updatedAt: string;
 };

package/dist/gemini-model-policy.d.ts

@@ -0,0 +1,56 @@
+import { type Model } from "./domain";
+import type { CompiledModelPolicy } from "./model-policy";
+/** The settings fragment understood by Gemini CLI 0.58.0. */
+export type GeminiModelPolicyFragment = {
+    modelConfigs: {
+        customOverrides: Array<{
+            match: {
+                model: string;
+            };
+            modelConfig: {
+                model: string;
+            };
+        }>;
+        modelChains: Record<string, Array<{
+            model: string;
+            isLastResort: true;
+        }>>;
+        modelDefinitions: Record<string, {
+            displayName: string;
+            tier: "custom";
+            family: "switcher";
+            isPreview: false;
+            isVisible: true;
+            features: {
+                thinking: false;
+                multimodalToolUse: boolean;
+            };
+        }>;
+        modelIdResolutions: Record<string, {
+            default: string;
+            contexts: [];
+        }>;
+        classifierIdResolutions: Record<string, {
+            default: string;
+            contexts: [];
+        }>;
+    };
+    agents?: {
+        overrides: {
+            codebase_investigator: {
+                modelConfig: {
+                    model: string;
+                };
+            };
+        };
+    };
+};
+/**
+ * Compile the portable Switcher policy into native Gemini 0.58.0 settings.
+ *
+ * Gemini's stable native route controls are modelConfigs.modelIdResolutions
+ * and agents.overrides.<agent>.modelConfig.model. Its modelConfigs.modelChains
+ * field receives terminal selected-model chains; the gateway owns explicit
+ * ordered fallback and retry semantics.
+ */
+export declare function compileGeminiModelPolicy(selectedModel: string, models: readonly Model[], compiled: CompiledModelPolicy): GeminiModelPolicyFragment;