gitpt 1.4.0 → 1.6.1

package/dist/llm/index.js

@@ -1,14 +1,9 @@
 import openai from "openai";
-import { getConfig } from "../config.js";
 import { formatBaseURL } from "../utils/formatBaseURL.js";
 export const OPENROUTER_API_URL = "https://openrouter.ai/api/v1";
 export const getLLMClient = (options) => {
-    const { baseURLOverride } = options || {};
-    const { apiKey, customLLMEndpoint, provider } = getConfig();
-    const localLLMEndpoint = provider === "local" ? customLLMEndpoint : undefined;
-    const baseURL = formatBaseURL(baseURLOverride ?? localLLMEndpoint ?? OPENROUTER_API_URL);
-    return new openai.OpenAI({
-        apiKey,
-        baseURL,
-    });
+    const baseURL = formatBaseURL(options?.baseURLOverride ?? OPENROUTER_API_URL);
+    // The OpenAI SDK requires a non-empty key even when the server ignores it.
+    const apiKey = options?.apiKey || "not-needed";
+    return new openai.OpenAI({ apiKey, baseURL });
 };

package/dist/llm/providers/anthropic/index.d.ts

@@ -0,0 +1,9 @@
+import { GitPTConfig } from "../../../config.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+export declare class AnthropicProvider extends OpenAICompatibleProvider {
+    static readonly id = "anthropic";
+    static readonly label = "Anthropic";
+    static readonly baseURL = "https://api.anthropic.com/v1";
+    static setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+    protected baseURL(): string;
+}

package/dist/llm/providers/anthropic/index.js

@@ -0,0 +1,31 @@
+import { OpenAICompatibleProvider, setupApiKeyProvider, } from "../openaiCompatible.js";
+const ANTHROPIC_VERSION = "2023-06-01";
+// Anthropic's /v1/models uses x-api-key auth (not the OpenAI SDK's bearer token).
+const listAnthropicModels = async (apiKey) => {
+    const response = await fetch("https://api.anthropic.com/v1/models?limit=100", {
+        headers: { "x-api-key": apiKey, "anthropic-version": ANTHROPIC_VERSION },
+    });
+    if (!response.ok) {
+        throw new Error(`${response.status} ${await response.text()}`);
+    }
+    const data = (await response.json())?.data ?? [];
+    return data.map((m) => ({
+        id: m.id,
+        name: m.display_name,
+    }));
+};
+export class AnthropicProvider extends OpenAICompatibleProvider {
+    static id = "anthropic";
+    static label = "Anthropic";
+    static baseURL = "https://api.anthropic.com/v1";
+    static setup(existingConfig) {
+        return setupApiKeyProvider(existingConfig, {
+            baseURL: AnthropicProvider.baseURL,
+            label: AnthropicProvider.label,
+            listModels: listAnthropicModels,
+        });
+    }
+    baseURL() {
+        return AnthropicProvider.baseURL;
+    }
+}

package/dist/llm/providers/apiKey.d.ts

@@ -0,0 +1,3 @@
+export declare const getApiKey: () => string | undefined;
+export declare const saveApiKey: (providerId: string, key: string) => void;
+export declare const promptApiKey: (existingKey?: string, label?: string) => Promise<string>;

package/dist/llm/providers/apiKey.js

@@ -0,0 +1,40 @@
+import inquirer from "inquirer";
+import { getConfig, saveConfig } from "../../config.js";
+import { maskApiKey } from "../../utils/maskApiKey.js";
+export const getApiKey = () => {
+    const { provider, apiKeys, apiKey } = getConfig();
+    return (provider && apiKeys?.[provider]) || apiKey;
+};
+export const saveApiKey = (providerId, key) => {
+    const { apiKeys } = getConfig();
+    saveConfig({ apiKeys: { ...apiKeys, [providerId]: key } });
+};
+export const promptApiKey = async (existingKey, label = "the provider") => {
+    if (existingKey) {
+        const { useExistingKey } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "useExistingKey",
+                message: `${label} API key:`,
+                choices: [
+                    {
+                        name: `Use existing key (${maskApiKey(existingKey)})`,
+                        value: true,
+                    },
+                    { name: "Enter a new API key", value: false },
+                ],
+            },
+        ]);
+        if (useExistingKey)
+            return existingKey;
+    }
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "apiKey",
+            message: `Enter your ${label} API key:`,
+            validate: (input) => (input ? true : "API key is required"),
+        },
+    ]);
+    return apiKey;
+};

package/dist/llm/providers/apple/client.d.ts

@@ -0,0 +1,3 @@
+import type { LLMClient } from "../../client.js";
+export declare const FM_BINARY = "fm";
+export declare const getAppleFoundationClient: () => LLMClient;

package/dist/llm/providers/apple/client.js

@@ -0,0 +1,87 @@
+import { spawn } from "child_process";
+export const FM_BINARY = "fm";
+const clean = (text) => text
+    .replace(/\x1b\[[0-9;]*m/g, "")
+    .replace(/[⠀-⣿]/g, "")
+    .trim();
+const messageText = (content) => {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => (part.type === "text" ? part.text : ""))
+            .join("");
+    }
+    return "";
+};
+const runFm = (args, stdin) => new Promise((resolve, reject) => {
+    const child = spawn(FM_BINARY, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+        if (error.code === "ENOENT") {
+            reject(new Error("The Apple Foundation Models CLI ('fm') was not found. It ships with macOS 27 and later."));
+            return;
+        }
+        reject(error);
+    });
+    child.on("close", (code) => {
+        const out = stdout.trim();
+        const err = clean(stderr);
+        if (code !== 0 || !out) {
+            reject(new Error(err || out || `'fm' exited with code ${code} and no output`));
+            return;
+        }
+        resolve(out);
+    });
+    child.stdin.on("error", () => { });
+    child.stdin.write(stdin);
+    child.stdin.end();
+});
+export const getAppleFoundationClient = () => {
+    return {
+        chat: {
+            completions: {
+                create: async (params) => {
+                    const model = params.model || "system";
+                    const instructions = params.messages
+                        .filter((m) => m.role === "system")
+                        .map((m) => messageText(m.content))
+                        .join("\n\n")
+                        .trim();
+                    const prompt = params.messages
+                        .filter((m) => m.role !== "system")
+                        .map((m) => messageText(m.content))
+                        .join("\n\n")
+                        .trim();
+                    const args = ["respond", "--no-stream", "--model", model];
+                    if (instructions) {
+                        args.push("--instructions", instructions);
+                    }
+                    const content = await runFm(args, prompt);
+                    return { choices: [{ message: { content } }] };
+                },
+            },
+        },
+        models: {
+            list: async () => ({
+                data: [
+                    { id: "system", created: 0, object: "model", owned_by: "apple" },
+                    { id: "pcc", created: 0, object: "model", owned_by: "apple" },
+                ],
+                hasNextPage: () => false,
+                getNextPage: async () => {
+                    throw new Error("No more pages");
+                },
+            }),
+        },
+    };
+};

package/dist/llm/providers/apple/index.d.ts

@@ -0,0 +1,13 @@
+import { GitPTConfig } from "../../../config.js";
+import type { LLMClient } from "../../client.js";
+import { Provider } from "../base.js";
+export declare class AppleProvider extends Provider {
+    static readonly id = "apple";
+    static readonly label = "Apple Foundation Models (macOS 27+)";
+    static isAvailable(): boolean;
+    static setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+    constructor(model: string);
+    getContextWindow(): Promise<number>;
+    countTokens(text: string): number;
+    protected getClient(): LLMClient;
+}

package/dist/llm/providers/apple/index.js

@@ -0,0 +1,77 @@
+import { spawnSync } from "child_process";
+import { platform } from "os";
+import chalk from "chalk";
+import { saveConfig } from "../../../config.js";
+import { selectModel } from "../../setup/selectModel.js";
+import { Provider } from "../base.js";
+import { getAppleFoundationClient } from "./client.js";
+import { CANDIDATE_MODELS, probeModel } from "./models.js";
+const MIN_MACOS_MAJOR = 27;
+export class AppleProvider extends Provider {
+    static id = "apple";
+    static label = "Apple Foundation Models (macOS 27+)";
+    static isAvailable() {
+        if (platform() !== "darwin")
+            return false;
+        const result = spawnSync("sw_vers", ["-productVersion"], {
+            encoding: "utf-8",
+        });
+        if (result.error || !result.stdout)
+            return false;
+        const major = parseInt(result.stdout.trim().split(".")[0], 10);
+        return Number.isFinite(major) && major >= MIN_MACOS_MAJOR;
+    }
+    static async setup(existingConfig) {
+        console.log(chalk.blue("Apple Foundation Models Setup"));
+        const probes = CANDIDATE_MODELS.map((model) => ({
+            model,
+            ...probeModel(model.id),
+        }));
+        if (probes.every((p) => p.reason === "fm-missing")) {
+            console.error(chalk.red("The Apple Foundation Models CLI ('fm') was not found. It ships with macOS 27 and later."));
+            process.exit(1);
+        }
+        const availableModels = probes
+            .filter((p) => p.available)
+            .map((p) => p.model);
+        if (availableModels.length === 0) {
+            console.error(chalk.red("No Apple Foundation Models are available in this context. Make sure Apple Intelligence is enabled in System Settings."));
+            process.exit(1);
+        }
+        const notes = probes
+            .filter((p) => !p.available)
+            .map((p) => `Note: Apple doesn't allow ${p.model.name} access from command-line tools.`);
+        const selectedModel = await selectModel(availableModels, existingConfig.model, notes);
+        const updatedConfig = {
+            ...existingConfig,
+            provider: "apple",
+            model: selectedModel,
+        };
+        saveConfig(updatedConfig);
+        console.log(chalk.green(`✓ Model set to: ${chalk.yellow(selectedModel)}`));
+        return updatedConfig;
+    }
+    constructor(model) {
+        super(model || "system");
+    }
+    async getContextWindow() {
+        // The Apple Foundation Model CLI does not provide a way to get the context window size.
+        // `fm` only enables `system` model for programmatic use, the context window is always 4096 tokens.
+        return 4096;
+    }
+    countTokens(text) {
+        const result = spawnSync("fm", ["token-count", "-q"], {
+            input: text,
+            encoding: "utf-8",
+        });
+        if (!result.error && result.stdout) {
+            const tokens = parseInt(result.stdout.replace(/[^0-9]/g, ""), 10);
+            if (Number.isFinite(tokens))
+                return tokens;
+        }
+        return super.countTokens(text);
+    }
+    getClient() {
+        return getAppleFoundationClient();
+    }
+}

package/dist/llm/providers/apple/models.d.ts

@@ -0,0 +1,14 @@
+export declare const CANDIDATE_MODELS: ({
+    id: string;
+    name: string;
+    context_length: number;
+} | {
+    id: string;
+    name: string;
+    context_length?: undefined;
+})[];
+export declare const probeModel: (modelId: string) => {
+    available: boolean;
+    reason?: string;
+};
+export declare const isAppleModelAvailable: (modelId: string) => boolean;

package/dist/llm/providers/apple/models.js

@@ -0,0 +1,21 @@
+import { spawnSync } from "child_process";
+export const CANDIDATE_MODELS = [
+    {
+        id: "system",
+        name: "Apple On-Device Foundation Model",
+        context_length: 4096,
+    },
+    { id: "pcc", name: "Private Cloud Compute (PCC)" },
+];
+export const probeModel = (modelId) => {
+    const result = spawnSync("fm", ["available", "--model", modelId], {
+        encoding: "utf-8",
+    });
+    if (result.error) {
+        return { available: false, reason: "fm-missing" };
+    }
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const available = /available/i.test(output) && !/not available|error/i.test(output);
+    return { available, reason: output.trim() };
+};
+export const isAppleModelAvailable = (modelId) => probeModel(modelId).available;

package/dist/llm/providers/base.d.ts

@@ -0,0 +1,30 @@
+import type { GitPTConfig } from "../../config.js";
+import type { LLMClient } from "../client.js";
+export interface CompletionRequest {
+    system: string;
+    user: string;
+    maxTokens: number;
+}
+export declare abstract class Provider {
+    readonly model: string;
+    static readonly requiresApiKey: boolean;
+    static readonly requiresEndpoint: boolean;
+    static isAvailable(): boolean;
+    readonly maxOutputTokens: number;
+    protected readonly usesCompletionTokensParam: boolean;
+    constructor(model: string);
+    getContextWindow(): Promise<number>;
+    countTokens(text: string): number;
+    protected abstract getClient(): LLMClient;
+    complete(req: CompletionRequest): Promise<string>;
+}
+export type ProviderClass = {
+    new (model: string): Provider;
+    readonly id: string;
+    readonly label: string;
+    readonly requiresApiKey: boolean;
+    readonly requiresEndpoint: boolean;
+    readonly baseURL?: string;
+    isAvailable(): boolean;
+    setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+};

package/dist/llm/providers/base.js

@@ -0,0 +1,36 @@
+export class Provider {
+    model;
+    static requiresApiKey = false;
+    static requiresEndpoint = false;
+    static isAvailable() {
+        return true;
+    }
+    maxOutputTokens = 1024;
+    // Newer OpenAI models require `max_completion_tokens`; most others use `max_tokens`.
+    usesCompletionTokensParam = false;
+    constructor(model) {
+        this.model = model;
+    }
+    async getContextWindow() {
+        return Number.POSITIVE_INFINITY;
+    }
+    countTokens(text) {
+        // Conservative estimate (code tokenizes higher than the usual ~4 chars/token),
+        // so chunks stay under the real context window when no exact tokenizer exists.
+        return Math.ceil(text.length / 3);
+    }
+    async complete(req) {
+        const tokenLimit = this.usesCompletionTokensParam
+            ? { max_completion_tokens: req.maxTokens }
+            : { max_tokens: req.maxTokens };
+        const response = await this.getClient().chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: "system", content: req.system },
+                { role: "user", content: req.user },
+            ],
+            ...tokenLimit,
+        });
+        return response.choices[0].message.content ?? "";
+    }
+}

package/dist/llm/providers/local/index.d.ts

@@ -0,0 +1,11 @@
+import { GitPTConfig } from "../../../config.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+export declare class LocalProvider extends OpenAICompatibleProvider {
+    static readonly id = "local";
+    static readonly label = "Local LLM";
+    static readonly requiresApiKey = false;
+    static readonly requiresEndpoint = true;
+    static setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+    getContextWindow(): Promise<number>;
+    protected baseURL(): string;
+}

package/dist/llm/providers/local/index.js

@@ -0,0 +1,96 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { getConfig, saveConfig } from "../../../config.js";
+import { getAvailableModels } from "../../setup/getAvailableModels.js";
+import { selectModel } from "../../setup/selectModel.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+const DEFAULT_CONTEXT_WINDOW = 4096;
+const detectContextWindow = async (endpoint, modelId) => {
+    try {
+        const origin = new URL(endpoint).origin;
+        const response = await fetch(`${origin}/api/v0/models`);
+        if (!response.ok)
+            return undefined;
+        const models = (await response.json())?.data ?? [];
+        const model = models.find((m) => m.id === modelId) ??
+            models.find((m) => m.state === "loaded");
+        const window = model?.loaded_context_length ?? model?.max_context_length;
+        return typeof window === "number" && window > 0 ? window : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export class LocalProvider extends OpenAICompatibleProvider {
+    static id = "local";
+    static label = "Local LLM";
+    static requiresApiKey = false;
+    static requiresEndpoint = true;
+    static async setup(existingConfig) {
+        console.log(chalk.blue("Local LLM Setup"));
+        const endpointAnswer = await inquirer.prompt([
+            {
+                type: "input",
+                name: "localLLMEndpoint",
+                message: "Enter local LLM API endpoint (e.g., http://127.0.0.1:1234):",
+                default: existingConfig.customLLMEndpoint || "http://127.0.0.1:1234",
+                validate: (input) => {
+                    if (!input)
+                        return "API endpoint is required";
+                    if (!input.startsWith("http://") && !input.startsWith("https://")) {
+                        return "Must be a valid URL starting with http:// or https://";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        const endpoint = endpointAnswer.localLLMEndpoint;
+        console.log(chalk.gray("Trying to fetch available models from local LLM server..."));
+        const models = await getAvailableModels({ baseURLOverride: endpoint });
+        let selectedModel;
+        if (models.length > 0) {
+            console.log(chalk.green(`✓ Found ${models.length} models available on your local LLM server`));
+            selectedModel = await selectModel(models, existingConfig.model);
+        }
+        else {
+            console.log(chalk.yellow("Could not fetch models from local LLM server, please enter model name manually"));
+            const modelAnswer = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "model",
+                    message: "Enter model name to use with local endpoint:",
+                    default: existingConfig.model,
+                    validate: (input) => input ? true : "Model name is required",
+                },
+            ]);
+            selectedModel = modelAnswer.model;
+        }
+        const contextWindow = (await detectContextWindow(endpoint, selectedModel)) ??
+            DEFAULT_CONTEXT_WINDOW;
+        console.log(chalk.gray(`Using a context window of ${contextWindow} tokens.`));
+        const updatedConfig = {
+            ...existingConfig,
+            provider: "local",
+            model: selectedModel,
+            customLLMEndpoint: endpoint,
+            contextWindow,
+        };
+        saveConfig(updatedConfig);
+        console.log(chalk.green("✓ Local LLM configuration saved"));
+        return updatedConfig;
+    }
+    async getContextWindow() {
+        const { contextWindow, customLLMEndpoint, model } = getConfig();
+        if (contextWindow)
+            return contextWindow;
+        const detected = await detectContextWindow(customLLMEndpoint ?? "", model ?? "");
+        if (detected) {
+            saveConfig({ contextWindow: detected });
+            return detected;
+        }
+        return DEFAULT_CONTEXT_WINDOW;
+    }
+    baseURL() {
+        return getConfig().customLLMEndpoint ?? "";
+    }
+}

package/dist/llm/providers/openai/index.d.ts

@@ -0,0 +1,10 @@
+import { GitPTConfig } from "../../../config.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+export declare class OpenAIProvider extends OpenAICompatibleProvider {
+    static readonly id = "openai";
+    static readonly label = "OpenAI";
+    static readonly baseURL = "https://api.openai.com/v1";
+    protected readonly usesCompletionTokensParam = true;
+    static setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+    protected baseURL(): string;
+}

package/dist/llm/providers/openai/index.js

@@ -0,0 +1,16 @@
+import { OpenAICompatibleProvider, setupApiKeyProvider, } from "../openaiCompatible.js";
+export class OpenAIProvider extends OpenAICompatibleProvider {
+    static id = "openai";
+    static label = "OpenAI";
+    static baseURL = "https://api.openai.com/v1";
+    usesCompletionTokensParam = true;
+    static setup(existingConfig) {
+        return setupApiKeyProvider(existingConfig, {
+            baseURL: OpenAIProvider.baseURL,
+            label: OpenAIProvider.label,
+        });
+    }
+    baseURL() {
+        return OpenAIProvider.baseURL;
+    }
+}

package/dist/llm/providers/openaiCompatible.d.ts

@@ -0,0 +1,15 @@
+import { GitPTConfig } from "../../config.js";
+import type { LLMClient } from "../client.js";
+import { Model } from "../setup/types.js";
+import { Provider } from "./base.js";
+export declare abstract class OpenAICompatibleProvider extends Provider {
+    static readonly requiresApiKey: boolean;
+    readonly maxOutputTokens = 2048;
+    protected abstract baseURL(): string;
+    protected getClient(): LLMClient;
+}
+export declare const setupApiKeyProvider: (existingConfig: GitPTConfig, opts: {
+    baseURL: string;
+    label: string;
+    listModels?: (apiKey: string) => Promise<Model[]>;
+}) => Promise<GitPTConfig>;

package/dist/llm/providers/openaiCompatible.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { saveConfig } from "../../config.js";
+import { getLLMClient } from "../index.js";
+import { getAvailableModels } from "../setup/getAvailableModels.js";
+import { selectModel } from "../setup/selectModel.js";
+import { getApiKey, promptApiKey, saveApiKey } from "./apiKey.js";
+import { Provider } from "./base.js";
+export class OpenAICompatibleProvider extends Provider {
+    static requiresApiKey = true;
+    // Headroom for reasoning models, which spend output tokens "thinking"
+    // before emitting the answer.
+    maxOutputTokens = 2048;
+    getClient() {
+        return getLLMClient({
+            baseURLOverride: this.baseURL(),
+            apiKey: getApiKey(),
+        });
+    }
+}
+export const setupApiKeyProvider = async (existingConfig, opts) => {
+    const { baseURL, label } = opts;
+    const listModels = opts.listModels ??
+        ((key) => getAvailableModels({ baseURLOverride: baseURL, apiKey: key }));
+    const providerId = existingConfig.provider ?? "";
+    const existingKey = existingConfig.apiKeys?.[providerId] ?? existingConfig.apiKey;
+    const apiKey = await promptApiKey(existingKey, label);
+    if (!apiKey) {
+        console.error(chalk.red(`API key is required for ${label}.`));
+        process.exit(1);
+    }
+    if (existingConfig.model) {
+        console.log("Current model:", chalk.yellow(existingConfig.model));
+        console.log("");
+    }
+    let selectedModel;
+    try {
+        console.log(chalk.gray(`Fetching available models from ${label}...`));
+        const models = await listModels(apiKey);
+        if (models.length > 0) {
+            console.log(chalk.green(`✓ Found ${models.length} models available with your API key`));
+        }
+        else {
+            console.log(chalk.yellow(`No models found from ${label}. Please specify a model manually.`));
+        }
+        selectedModel = await selectModel(models, existingConfig.model);
+    }
+    catch (error) {
+        console.error(chalk.yellow(`Error fetching models: ${error}`));
+        const modelAnswer = await inquirer.prompt([
+            {
+                type: "input",
+                name: "model",
+                message: "Enter model identifier:",
+                validate: (input) => input ? true : "Model identifier is required",
+            },
+        ]);
+        selectedModel = modelAnswer.model;
+    }
+    saveApiKey(providerId, apiKey);
+    const finalConfig = {
+        ...existingConfig,
+        model: selectedModel,
+        apiKeys: { ...existingConfig.apiKeys, [providerId]: apiKey },
+    };
+    saveConfig(finalConfig);
+    console.log(chalk.green(`✓ Model set to: ${chalk.yellow(selectedModel)}`));
+    return finalConfig;
+};

package/dist/llm/providers/openrouter/index.d.ts

@@ -0,0 +1,9 @@
+import { GitPTConfig } from "../../../config.js";
+import { OpenAICompatibleProvider } from "../openaiCompatible.js";
+export declare class OpenRouterProvider extends OpenAICompatibleProvider {
+    static readonly id = "openrouter";
+    static readonly label = "OpenRouter (remote)";
+    static readonly baseURL = "https://openrouter.ai/api/v1";
+    static setup(existingConfig: GitPTConfig): Promise<GitPTConfig>;
+    protected baseURL(): string;
+}

package/dist/llm/providers/openrouter/index.js

@@ -0,0 +1,16 @@
+import { OPENROUTER_API_URL } from "../../index.js";
+import { OpenAICompatibleProvider, setupApiKeyProvider, } from "../openaiCompatible.js";
+export class OpenRouterProvider extends OpenAICompatibleProvider {
+    static id = "openrouter";
+    static label = "OpenRouter (remote)";
+    static baseURL = OPENROUTER_API_URL;
+    static setup(existingConfig) {
+        return setupApiKeyProvider(existingConfig, {
+            baseURL: OpenRouterProvider.baseURL,
+            label: OpenRouterProvider.label,
+        });
+    }
+    baseURL() {
+        return OpenRouterProvider.baseURL;
+    }
+}

package/dist/llm/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Provider, ProviderClass } from "./providers/base.js";
+export declare const PROVIDERS: ProviderClass[];
+export declare const getProviderClass: (id: string | undefined) => ProviderClass | undefined;
+export declare const getProvider: () => Provider;
+export declare const validateConfig: () => {
+    isValid: boolean;
+    errors: string[];
+};