@hasna/switcher 0.1.0 → 0.1.2

package/dist/cline-backend.d.ts

@@ -0,0 +1,7 @@
+import type { HarnessLaunchInput, PreparedLaunch } from "./harness-types";
+/**
+ * Prepare Cline's native provider and model registries in an isolated data
+ * directory. Cline resolves OPENAI_API_KEY/ANTHROPIC_API_KEY from the child
+ * environment; no apiKey or auth token is written to either registry.
+ */
+export declare function prepareClineLaunch(input: HarnessLaunchInput): Promise<PreparedLaunch>;

package/dist/credentials.d.ts

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { CommandInterrupted, type ProviderInput } from "./domain";
+declare const keychain: z.ZodObject<{
+    kind: z.ZodLiteral<"keychain">;
+    service: z.ZodString;
+    account: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "keychain";
+    service: string;
+    account: string;
+}, {
+    kind: "keychain";
+    service: string;
+    account: string;
+}>;
+export declare const credentialBindingSchema: z.ZodObject<{
+    schema: z.ZodLiteral<1>;
+    credentialEnv: z.ZodString;
+    origins: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"keychain">;
+        service: z.ZodString;
+        account: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "keychain";
+        service: string;
+        account: string;
+    }, {
+        kind: "keychain";
+        service: string;
+        account: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"vault">;
+        key: z.ZodString;
+        url: z.ZodEffects<z.ZodString, string, string>;
+        executable: z.ZodEffects<z.ZodString, string, string>;
+        operator: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"env">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "env";
+        }, {
+            kind: "env";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"keychain">;
+            account: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "keychain";
+            account: string;
+        }, {
+            kind: "keychain";
+            account: string;
+        }>]>;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+    }, {
+        url: string;
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+    }>]>;
+}, "strict", z.ZodTypeAny, {
+    credentialEnv: string;
+    source: {
+        kind: "keychain";
+        service: string;
+        account: string;
+    } | {
+        url: string;
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+    };
+    schema: 1;
+    origins: string[];
+}, {
+    credentialEnv: string;
+    source: {
+        kind: "keychain";
+        service: string;
+        account: string;
+    } | {
+        url: string;
+        key: string;
+        executable: string;
+        kind: "vault";
+        operator: {
+            kind: "env";
+        } | {
+            kind: "keychain";
+            account: string;
+        };
+    };
+    schema: 1;
+    origins: string[];
+}>;
+export type CredentialBinding = z.infer<typeof credentialBindingSchema>;
+export declare class CredentialBindings {
+    readonly env: NodeJS.ProcessEnv;
+    readonly directory: string;
+    constructor(env?: NodeJS.ProcessEnv);
+    private path;
+    private readableDirectory;
+    get(name: string): Promise<CredentialBinding | undefined>;
+    list(): Promise<CredentialBinding[]>;
+    bind(input: CredentialBinding): Promise<{
+        credentialEnv: string;
+        source: {
+            kind: "keychain";
+            service: string;
+            account: string;
+        } | {
+            url: string;
+            key: string;
+            executable: string;
+            kind: "vault";
+            operator: {
+                kind: "env";
+            } | {
+                kind: "keychain";
+                account: string;
+            };
+        };
+        schema: 1;
+        origins: string[];
+    }>;
+    remove(name: string): Promise<{
+        removed: string;
+    }>;
+}
+export declare function credentialReference(selector: string): string;
+export declare function validateVaultExecutable(path: string): Promise<string>;
+export declare function bindingTarget(selector: string, override?: string, allowedOrigins?: string[]): {
+    credentialEnv: string;
+    origins: string[];
+};
+declare function readKeychain(source: z.infer<typeof keychain>): Promise<string>;
+export declare class CredentialResolver {
+    readonly env: NodeJS.ProcessEnv;
+    private readonly keychainRead;
+    readonly bindings: CredentialBindings;
+    constructor(env?: NodeJS.ProcessEnv, keychainRead?: typeof readKeychain);
+    resolve(provider: ProviderInput): Promise<string | undefined>;
+    check(name: string): Promise<{
+        credentialEnv: string;
+        source: string;
+        available: boolean;
+        length: number;
+        sha256: string;
+        providerAuthentication: string;
+    }>;
+}
+export declare class CredentialInterrupted extends CommandInterrupted {
+    constructor(exitCode: number);
+}
+/** 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

@@ -0,0 +1,6 @@
+import { SwitcherClient, type Provider, type Profile } from "./sdk";
+import { type Model } 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>;

package/dist/domain.d.ts

@@ -1,177 +1,294 @@
 import { z } from "zod";
-export declare const VERSION = "0.1.0";
-export declare const harnessSchema: z.ZodEnum<["claude", "codex", "grok", "opencode2"]>;
-export declare const protocolSchema: z.ZodEnum<["anthropic-messages", "openai-responses", "openai-chat"]>;
+export type { AuthStyle } from "./auth";
+export declare const VERSION = "0.1.2";
+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;
 export declare function endpoint(value: string): string;
 export declare const modelSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
+    available: z.ZodOptional<z.ZodBoolean>;
     contextWindow: z.ZodOptional<z.ZodNumber>;
     maxOutputTokens: z.ZodOptional<z.ZodNumber>;
     inputModalities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     outputModalities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     supportedParameters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    supportedGenerationMethods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     name: string;
     description?: string | undefined;
+    available?: boolean | undefined;
     contextWindow?: number | undefined;
     maxOutputTokens?: number | undefined;
     inputModalities?: string[] | undefined;
     outputModalities?: string[] | undefined;
     supportedParameters?: string[] | undefined;
+    supportedGenerationMethods?: string[] | undefined;
 }, {
     id: string;
     name: string;
     description?: string | undefined;
+    available?: boolean | undefined;
     contextWindow?: number | undefined;
     maxOutputTokens?: number | undefined;
     inputModalities?: string[] | undefined;
     outputModalities?: string[] | undefined;
     supportedParameters?: string[] | undefined;
+    supportedGenerationMethods?: string[] | undefined;
 }>;
 export declare const providerInputSchema: z.ZodEffects<z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     baseUrl: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    protocol: z.ZodEnum<["anthropic-messages", "openai-responses", "openai-chat"]>;
+    protocol: z.ZodEnum<["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]>;
     credentialEnv: z.ZodOptional<z.ZodString>;
-    authStyle: z.ZodDefault<z.ZodEnum<["bearer", "x-api-key"]>>;
+    authStyle: z.ZodDefault<z.ZodEnum<["bearer", "x-api-key", "api-key"]>>;
+    catalogBaseUrl: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    catalogFormat: z.ZodOptional<z.ZodEnum<["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]>>;
+    catalogAuthStyle: z.ZodOptional<z.ZodEnum<["bearer", "x-api-key", "api-key", "none"]>>;
+    catalogCredentialEnv: z.ZodOptional<z.ZodString>;
+    catalogAccountId: z.ZodOptional<z.ZodString>;
     modelsPath: z.ZodDefault<z.ZodString>;
     manualModels: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
+        available: z.ZodOptional<z.ZodBoolean>;
         contextWindow: z.ZodOptional<z.ZodNumber>;
         maxOutputTokens: z.ZodOptional<z.ZodNumber>;
         inputModalities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         outputModalities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         supportedParameters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        supportedGenerationMethods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strict", z.ZodTypeAny, {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }, {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     name: string;
     baseUrl: string;
-    protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
-    authStyle: "bearer" | "x-api-key";
+    protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+    authStyle: "bearer" | "x-api-key" | "api-key";
     modelsPath: string;
     manualModels: {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }[];
     credentialEnv?: string | undefined;
+    catalogBaseUrl?: string | undefined;
+    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none" | undefined;
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    catalogCredentialEnv?: string | undefined;
+    catalogAccountId?: string | undefined;
 }, {
     id: string;
     name: string;
     baseUrl: string;
-    protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
+    protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
     credentialEnv?: string | undefined;
-    authStyle?: "bearer" | "x-api-key" | undefined;
+    authStyle?: "bearer" | "x-api-key" | "api-key" | undefined;
+    catalogBaseUrl?: string | undefined;
+    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none" | undefined;
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    catalogCredentialEnv?: string | undefined;
+    catalogAccountId?: string | undefined;
     modelsPath?: string | undefined;
     manualModels?: {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }[] | undefined;
 }>, {
     id: string;
     name: string;
     baseUrl: string;
-    protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
-    authStyle: "bearer" | "x-api-key";
+    protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+    authStyle: "bearer" | "x-api-key" | "api-key";
     modelsPath: string;
     manualModels: {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }[];
     credentialEnv?: string | undefined;
+    catalogBaseUrl?: string | undefined;
+    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none" | undefined;
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    catalogCredentialEnv?: string | undefined;
+    catalogAccountId?: string | undefined;
 }, {
     id: string;
     name: string;
     baseUrl: string;
-    protocol: "anthropic-messages" | "openai-responses" | "openai-chat";
+    protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
     credentialEnv?: string | undefined;
-    authStyle?: "bearer" | "x-api-key" | undefined;
+    authStyle?: "bearer" | "x-api-key" | "api-key" | undefined;
+    catalogBaseUrl?: string | undefined;
+    catalogFormat?: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none" | undefined;
+    catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    catalogCredentialEnv?: string | undefined;
+    catalogAccountId?: string | undefined;
     modelsPath?: string | undefined;
     manualModels?: {
         id: string;
         name: string;
         description?: string | undefined;
+        available?: boolean | undefined;
         contextWindow?: number | undefined;
         maxOutputTokens?: number | undefined;
         inputModalities?: string[] | undefined;
         outputModalities?: string[] | undefined;
         supportedParameters?: string[] | undefined;
+        supportedGenerationMethods?: string[] | undefined;
     }[] | undefined;
 }>;
+export declare const providerPresetSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    credentialEnv: z.ZodOptional<z.ZodString>;
+    credentialAliases: z.ZodArray<z.ZodString, "many">;
+    protocols: z.ZodArray<z.ZodObject<{
+        protocol: z.ZodEnum<["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]>;
+        baseUrl: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        authStyle: z.ZodEnum<["bearer", "x-api-key", "api-key"]>;
+        catalogBaseUrl: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        catalogFormat: z.ZodEnum<["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]>;
+        catalogAuthStyle: z.ZodOptional<z.ZodEnum<["bearer", "x-api-key", "api-key", "none"]>>;
+        modelsPath: z.ZodString;
+        notes: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+        authStyle: "bearer" | "x-api-key" | "api-key";
+        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none";
+        modelsPath: string;
+        notes: string[];
+        baseUrl?: string | undefined;
+        catalogBaseUrl?: string | undefined;
+        catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    }, {
+        protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+        authStyle: "bearer" | "x-api-key" | "api-key";
+        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none";
+        modelsPath: string;
+        notes: string[];
+        baseUrl?: string | undefined;
+        catalogBaseUrl?: string | undefined;
+        catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    }>, "many">;
+    sources: z.ZodArray<z.ZodString, "many">;
+    verification: z.ZodLiteral<"documented">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    credentialAliases: string[];
+    protocols: {
+        protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+        authStyle: "bearer" | "x-api-key" | "api-key";
+        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none";
+        modelsPath: string;
+        notes: string[];
+        baseUrl?: string | undefined;
+        catalogBaseUrl?: string | undefined;
+        catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    }[];
+    sources: string[];
+    verification: "documented";
+    credentialEnv?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    credentialAliases: string[];
+    protocols: {
+        protocol: "anthropic-messages" | "openai-responses" | "openai-chat" | "gemini-generate-content";
+        authStyle: "bearer" | "x-api-key" | "api-key";
+        catalogFormat: "openai" | "ollama" | "mistral" | "together" | "fireworks" | "dashscope" | "gemini" | "none";
+        modelsPath: string;
+        notes: string[];
+        baseUrl?: string | undefined;
+        catalogBaseUrl?: string | undefined;
+        catalogAuthStyle?: "bearer" | "x-api-key" | "api-key" | "none" | undefined;
+    }[];
+    sources: string[];
+    verification: "documented";
+    credentialEnv?: string | undefined;
+}>;
+export type ProviderPreset = z.infer<typeof providerPresetSchema>;
 export declare const profileInputSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     providerId: z.ZodString;
-    harness: z.ZodEnum<["claude", "codex", "grok", "opencode2"]>;
+    harness: z.ZodEnum<["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]>;
     model: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     id: string;
     name: string;
     providerId: string;
-    harness: "claude" | "codex" | "grok" | "opencode2";
+    harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
 }, {
     id: string;
     name: string;
     providerId: string;
-    harness: "claude" | "codex" | "grok" | "opencode2";
+    harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
 }>;
 export declare const runInputSchema: z.ZodObject<{
     profileId: z.ZodString;
-    harness: z.ZodEnum<["claude", "codex", "grok", "opencode2"]>;
+    harness: z.ZodEnum<["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]>;
     model: z.ZodString;
     planToken: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    harness: "claude" | "codex" | "grok" | "opencode2";
+    harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
     profileId: string;
     planToken: string;
 }, {
-    harness: "claude" | "codex" | "grok" | "opencode2";
+    harness: "gemini" | "claude" | "codex" | "grok" | "opencode" | "opencode2" | "pi" | "omp" | "dsh" | "cline" | "hermes" | "prime-agent" | "aider" | "kilo";
     model: string;
     profileId: string;
     planToken: string;
@@ -226,6 +343,12 @@ export declare class Fault extends Error {
     code: string;
     constructor(status: number, code: string, message: string);
 }
+export declare class CommandInterrupted extends Fault {
+    readonly exitCode: number;
+    constructor(exitCode: number, message: string);
+}
 export declare function parse<T>(schema: z.ZodType<T, any, any>, value: unknown): T;
 export declare function compatible(harness: Profile["harness"], protocol: Provider["protocol"]): boolean;
+export declare function validateHarnessProvider(harness: Profile["harness"], provider: Pick<Provider, "protocol" | "authStyle">): void;
 export declare function codingEligible(model: Model): boolean;
+export declare function harnessEligible(model: Model, harness: Profile["harness"]): boolean;

package/dist/dsh-args.d.ts

@@ -0,0 +1,5 @@
+/** Only shipped DSH profiles with a composition-owned model route are supported. */
+export declare function dshArguments(input: string[]): {
+    profile: string;
+    args: string[];
+};

package/dist/gemini-bridge.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessLaunchInput } from "./harness-types";
+export declare function geminiBridge(input: HarnessLaunchInput): {
+    baseUrl: string;
+    token: string;
+    cleanup: () => Promise<void>;
+};

package/dist/gemini-config.d.ts

@@ -0,0 +1,12 @@
+import type { HarnessLaunchInput, PreparedLaunch } from "./harness-types";
+type Settings = Record<string, any>;
+export declare function validateGeminiConfiguration(cwd: string, env?: NodeJS.ProcessEnv): Promise<{
+    home: string;
+    defaults: Settings;
+    user: Settings;
+    system: Settings;
+    contextNames: string[];
+    trustPath: string;
+}>;
+export declare function prepareGemini(input: HarnessLaunchInput): Promise<PreparedLaunch>;
+export {};