@travisennis/acai 0.0.1

package/dist/source/models/ai-config.js

@@ -0,0 +1,87 @@
+const THINKING_TIERS = [
+    {
+        pattern: /\b(ultrathink|think super hard|think really hard|think intensely)\b/i,
+        budget: 31999,
+        effort: "high",
+    },
+    {
+        pattern: /\b(megathink|think (very )?hard|think (a lot|more|about it))\b/i,
+        budget: 10000,
+        effort: "medium",
+    },
+    {
+        pattern: /\bthink\b/i, // Catch-all for standalone "think"
+        budget: 4000,
+        effort: "low",
+    },
+];
+function calculateThinkingLevel(userInput) {
+    let tokenBudget = 0; // Default
+    let effort = "none";
+    for (const tier of THINKING_TIERS) {
+        if (tier.pattern.test(userInput)) {
+            tokenBudget = tier.budget;
+            effort = tier.effort;
+            break; // Use highest priority match
+        }
+    }
+    return { tokenBudget, effort };
+}
+export class AiConfig {
+    modelMetadata;
+    prompt;
+    constructor({ modelMetadata, prompt, }) {
+        this.modelMetadata = modelMetadata;
+        this.prompt = prompt;
+    }
+    getMaxTokens() {
+        const modelConfig = this.modelMetadata;
+        const thinkingLevel = calculateThinkingLevel(this.prompt);
+        const maxTokens = modelConfig.provider === "anthropic" && modelConfig.supportsReasoning
+            ? modelConfig.maxOutputTokens - thinkingLevel.tokenBudget
+            : modelConfig.maxOutputTokens;
+        return maxTokens;
+    }
+    getProviderOptions() {
+        const modelConfig = this.modelMetadata;
+        const thinkingLevel = calculateThinkingLevel(this.prompt);
+        if (modelConfig.supportsReasoning && thinkingLevel.effort !== "none") {
+            switch (modelConfig.provider) {
+                case "anthropic":
+                    return {
+                        anthropic: {
+                            thinking: {
+                                type: "enabled",
+                                budgetTokens: thinkingLevel.tokenBudget,
+                            },
+                        },
+                    };
+                case "openai":
+                    return { openai: { reasoningEffort: thinkingLevel.effort } };
+                case "google": {
+                    return {
+                        google: {
+                            thinkingConfig: {
+                                thinkingBudget: thinkingLevel.tokenBudget,
+                            },
+                        },
+                    };
+                }
+                case "openrouter": {
+                    return {
+                        openrouter: {
+                            reasoning: {
+                                enabled: true,
+                                effort: thinkingLevel.effort,
+                            },
+                        },
+                    };
+                }
+                default:
+                    return {};
+            }
+        }
+        // If supportsReasoning is false, or no provider case matched
+        return {};
+    }
+}

package/dist/source/models/anthropic-provider.d.ts

@@ -0,0 +1,25 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const anthropicModels: {
+    readonly opus: import("@ai-sdk/provider").LanguageModelV2;
+    readonly sonnet: import("@ai-sdk/provider").LanguageModelV2;
+    readonly sonnet37: import("@ai-sdk/provider").LanguageModelV2;
+    readonly "sonnet37-token-efficient-tools": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "sonnet37-128k": import("@ai-sdk/provider").LanguageModelV2;
+    readonly sonnet35: import("@ai-sdk/provider").LanguageModelV2;
+    readonly haiku: import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `anthropic:${keyof typeof anthropicModels}`;
+export declare const anthropicModelNames: ModelName[];
+export declare const anthropicProvider: {
+    anthropic: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "opus" | "sonnet" | "sonnet37" | "sonnet37-token-efficient-tools" | "sonnet37-128k" | "sonnet35" | "haiku"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const anthropicModelRegistry: {
+    [K in ModelName]: ModelMetadata<ModelName>;
+};
+export {};

package/dist/source/models/anthropic-provider.js

@@ -0,0 +1,184 @@
+import { createAnthropic, anthropic as originalAnthropic, } from "@ai-sdk/anthropic";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { isRecord } from "@travisennis/stdlib/typeguards";
+import { customProvider } from "ai";
+// Helper function copied from original providers.ts
+function addCacheControlToTools(body) {
+    const parsedBody = JSON.parse(body);
+    if (isRecord(parsedBody)) {
+        const tools = parsedBody["tools"];
+        if (Array.isArray(tools)) {
+            tools.at(-1).cache_control = { type: "ephemeral" };
+        }
+    }
+    return JSON.stringify(parsedBody);
+}
+const anthropicModels = {
+    opus: createAnthropic({
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-4-opus-20250514"),
+    sonnet: createAnthropic({
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-4-sonnet-20250514"),
+    sonnet37: createAnthropic({
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-3-7-sonnet-20250219"),
+    "sonnet37-token-efficient-tools": createAnthropic({
+        headers: {
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "token-efficient-tools-2025-02-19",
+        },
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-3-7-sonnet-20250219"),
+    "sonnet37-128k": createAnthropic({
+        headers: {
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "output-128k-2025-02-19",
+        },
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-3-7-sonnet-20250219"),
+    sonnet35: createAnthropic({
+        headers: {
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "max-tokens-3-5-sonnet-2024-07-15",
+        },
+        fetch(input, init) {
+            const body = init?.body;
+            if (body && typeof body === "string") {
+                init.body = addCacheControlToTools(body);
+            }
+            return fetch(input, init);
+        },
+    })("claude-3-5-sonnet-20241022"),
+    haiku: originalAnthropic("claude-3-5-haiku-20241022"),
+};
+export const anthropicModelNames = objectKeys(anthropicModels).map((key) => `anthropic:${key}`);
+export const anthropicProvider = {
+    anthropic: customProvider({
+        languageModels: anthropicModels,
+        fallbackProvider: originalAnthropic,
+    }),
+};
+export const anthropicModelRegistry = {
+    "anthropic:opus": {
+        id: "anthropic:opus",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 64000,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000015,
+        costPerOutputToken: 0.000075,
+        category: "powerful",
+    },
+    "anthropic:sonnet": {
+        id: "anthropic:sonnet",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 64000,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000003,
+        costPerOutputToken: 0.000015,
+        category: "balanced",
+    },
+    "anthropic:sonnet37": {
+        id: "anthropic:sonnet37",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 64000,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000003,
+        costPerOutputToken: 0.000015,
+        category: "balanced",
+    },
+    "anthropic:sonnet37-token-efficient-tools": {
+        id: "anthropic:sonnet37-token-efficient-tools",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 64000,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000003,
+        costPerOutputToken: 0.000015,
+        category: "balanced",
+    },
+    "anthropic:sonnet37-128k": {
+        id: "anthropic:sonnet37-128k",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 128000,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000003,
+        costPerOutputToken: 0.000015,
+        category: "powerful",
+    },
+    "anthropic:sonnet35": {
+        id: "anthropic:sonnet35",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 8096,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000003,
+        costPerOutputToken: 0.000015,
+        category: "balanced",
+    },
+    "anthropic:haiku": {
+        id: "anthropic:haiku",
+        provider: "anthropic",
+        contextWindow: 200000,
+        maxOutputTokens: 4096,
+        defaultTemperature: 0.3,
+        promptFormat: "xml",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0.0000008,
+        costPerOutputToken: 0.000004,
+        category: "fast",
+    },
+};

package/dist/source/models/deepseek-provider.d.ts

@@ -0,0 +1,20 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const deepseekModels: {
+    readonly "deepseek-chat": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "deepseek-reasoner": import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `deepseek:${keyof typeof deepseekModels}`;
+export declare const deepseekModelNames: ModelName[];
+export declare const deepseekProvider: {
+    deepseek: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "deepseek-chat" | "deepseek-reasoner"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const deepseekModelRegistry: {
+    [K in ModelName]: ModelMetadata<ModelName>;
+};
+export {};

package/dist/source/models/deepseek-provider.js

@@ -0,0 +1,42 @@
+import { deepseek as originalDeepseek } from "@ai-sdk/deepseek";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+const deepseekModels = {
+    "deepseek-chat": originalDeepseek("deepseek-chat"),
+    "deepseek-reasoner": originalDeepseek("deepseek-reasoner"),
+};
+export const deepseekModelNames = objectKeys(deepseekModels).map((key) => `deepseek:${key}`);
+export const deepseekProvider = {
+    deepseek: customProvider({
+        languageModels: deepseekModels,
+        fallbackProvider: originalDeepseek,
+    }),
+};
+export const deepseekModelRegistry = {
+    "deepseek:deepseek-chat": {
+        id: "deepseek:deepseek-chat",
+        provider: "deepseek",
+        contextWindow: 128000,
+        maxOutputTokens: 8000,
+        defaultTemperature: 0.3,
+        promptFormat: "bracket",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0.0000012, // Check official pricing
+        costPerOutputToken: 0.0000012, // Check official pricing
+        category: "balanced",
+    },
+    "deepseek:deepseek-reasoner": {
+        id: "deepseek:deepseek-reasoner",
+        provider: "deepseek",
+        contextWindow: 128000,
+        maxOutputTokens: 32768,
+        defaultTemperature: 0.6,
+        promptFormat: "bracket",
+        supportsReasoning: true,
+        supportsToolCalling: true, // Check if this model supports tools
+        costPerInputToken: 0.00000055, // Check official pricing
+        costPerOutputToken: 0.00000219, // Check official pricing
+        category: "balanced",
+    },
+};

package/dist/source/models/google-provider.d.ts

@@ -0,0 +1,19 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const googleModels: {
+    readonly flash25lite: import("@ai-sdk/provider").LanguageModelV2;
+    readonly pro25: import("@ai-sdk/provider").LanguageModelV2;
+    readonly flash25: import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `google:${keyof typeof googleModels}`;
+export declare const googleModelNames: ModelName[];
+export declare const googleProvider: {
+    google: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "flash25lite" | "pro25" | "flash25"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const googleModelRegistry: Record<ModelName, ModelMetadata<ModelName>>;
+export {};

package/dist/source/models/google-provider.js

@@ -0,0 +1,56 @@
+import { google as originalGoogle } from "@ai-sdk/google";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+const googleModels = {
+    flash25lite: originalGoogle("gemini-2.5-flash-lite-preview-06-17"),
+    pro25: originalGoogle("gemini-2.5-pro"),
+    flash25: originalGoogle("gemini-2.5-flash"),
+};
+export const googleModelNames = objectKeys(googleModels).map((key) => `google:${key}`);
+export const googleProvider = {
+    google: customProvider({
+        languageModels: googleModels,
+        fallbackProvider: originalGoogle,
+    }),
+};
+export const googleModelRegistry = {
+    "google:flash25lite": {
+        id: "google:flash25lite",
+        provider: "google",
+        contextWindow: 1000000,
+        maxOutputTokens: 8192,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0,
+        costPerOutputToken: 0,
+        category: "fast",
+    },
+    "google:pro25": {
+        id: "google:pro25",
+        provider: "google",
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        defaultTemperature: 0.7,
+        promptFormat: "markdown",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0,
+        costPerOutputToken: 0,
+        category: "powerful",
+    },
+    "google:flash25": {
+        id: "google:flash25",
+        provider: "google",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.00000015,
+        costPerOutputToken: 0.0000035,
+        category: "balanced",
+    },
+};

package/dist/source/models/manager.d.ts

@@ -0,0 +1,15 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { type ModelMetadata, type ModelName } from "./providers.ts";
+type App = "repl" | "cli" | "title-conversation" | "conversation-summarizer" | "conversation-analyzer" | "tool-repair" | "init-project" | "task-agent";
+export declare class ModelManager {
+    private modelMap;
+    private modelMetadataMap;
+    private stateDir;
+    constructor({ stateDir }: {
+        stateDir: string;
+    });
+    setModel(app: App, model: ModelName): void;
+    getModel(app: App): LanguageModelV2;
+    getModelMetadata(app: App): ModelMetadata<ModelName>;
+}
+export {};

package/dist/source/models/manager.js

@@ -0,0 +1,48 @@
+import { wrapLanguageModel } from "ai";
+import { auditMessage, createRateLimitMiddleware, } from "../middleware/index.js";
+import { languageModel, modelRegistry, } from "./providers.js";
+function getLanguageModel({ model, app, stateDir, }) {
+    const langModel = wrapLanguageModel({
+        model: languageModel(model),
+        middleware: [
+            createRateLimitMiddleware({ requestsPerMinute: 30 }),
+            auditMessage({ filePath: stateDir, app }),
+        ],
+    });
+    return langModel;
+}
+export class ModelManager {
+    modelMap;
+    modelMetadataMap;
+    stateDir;
+    constructor({ stateDir }) {
+        this.modelMap = new Map();
+        this.modelMetadataMap = new Map();
+        this.stateDir = stateDir;
+    }
+    setModel(app, model) {
+        this.modelMap.set(app, getLanguageModel({
+            model,
+            app,
+            stateDir: this.stateDir,
+        }));
+        const modelMetadata = modelRegistry[model];
+        if (modelMetadata) {
+            this.modelMetadataMap.set(app, modelMetadata);
+        }
+    }
+    getModel(app) {
+        const model = this.modelMap.get(app);
+        if (!model) {
+            throw new Error("Model not initialized.");
+        }
+        return model;
+    }
+    getModelMetadata(app) {
+        const metadata = this.modelMetadataMap.get(app);
+        if (!metadata) {
+            throw new Error("Model not initialized.");
+        }
+        return metadata;
+    }
+}

package/dist/source/models/openai-provider.d.ts

@@ -0,0 +1,22 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const openaiModels: {
+    readonly "gpt-4.1": import("@ai-sdk/provider").LanguageModelV2;
+    readonly o3: import("@ai-sdk/provider").LanguageModelV2;
+    readonly "o4-mini": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "codex-mini": import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `openai:${keyof typeof openaiModels}`;
+export declare const openaiModelNames: ModelName[];
+export declare const openaiProvider: {
+    openai: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "o3" | "gpt-4.1" | "o4-mini" | "codex-mini"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const openaiModelRegistry: {
+    [K in ModelName]: ModelMetadata<ModelName>;
+};
+export {};

package/dist/source/models/openai-provider.js

@@ -0,0 +1,70 @@
+import { openai as originalOpenAi } from "@ai-sdk/openai";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+const openaiModels = {
+    "gpt-4.1": originalOpenAi("gpt-4.1"),
+    o3: originalOpenAi.responses("o3"),
+    "o4-mini": originalOpenAi.responses("o4-mini"),
+    "codex-mini": originalOpenAi("codex-mini-latest"),
+};
+export const openaiModelNames = objectKeys(openaiModels).map((key) => `openai:${key}`);
+export const openaiProvider = {
+    openai: customProvider({
+        languageModels: openaiModels,
+        fallbackProvider: originalOpenAi,
+    }),
+};
+export const openaiModelRegistry = {
+    "openai:gpt-4.1": {
+        id: "openai:gpt-4.1",
+        provider: "openai",
+        contextWindow: 1000000,
+        maxOutputTokens: 32768,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0.000002,
+        costPerOutputToken: 0.000008,
+        category: "balanced",
+    },
+    "openai:o3": {
+        id: "openai:o3",
+        provider: "openai",
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.00001,
+        costPerOutputToken: 0.00004,
+        category: "powerful",
+    },
+    "openai:o4-mini": {
+        id: "openai:o4-mini",
+        provider: "openai",
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: true,
+        supportsToolCalling: true,
+        costPerInputToken: 0.0000011,
+        costPerOutputToken: 0.0000044,
+        category: "balanced",
+    },
+    "openai:codex-mini": {
+        id: "openai:codex-mini",
+        provider: "openai",
+        contextWindow: 200000,
+        maxOutputTokens: 100000,
+        defaultTemperature: 0.3,
+        promptFormat: "markdown",
+        supportsReasoning: false,
+        supportsToolCalling: true,
+        costPerInputToken: 0.0000015,
+        costPerOutputToken: 0.000006,
+        category: "balanced",
+    },
+};

package/dist/source/models/openrouter-provider.d.ts

@@ -0,0 +1,36 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const openrouterModels: {
+    readonly "deepseek-v3": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "deepseek-r1": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "deepseek-v3-free": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "deepseek-r1-free": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "gemini-flash25": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "gemini-pro25": import("@ai-sdk/provider").LanguageModelV2;
+    readonly sonnet4: import("@ai-sdk/provider").LanguageModelV2;
+    readonly opus4: import("@ai-sdk/provider").LanguageModelV2;
+    readonly "opus-4.1": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "gpt-4.1": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "kimi-k2": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "kimi-k2-free": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "devstral-medium": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "qwen3-coder": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "qwen3-coder-free": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "glm-4.5": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "gpt-5": import("@ai-sdk/provider").LanguageModelV2;
+    readonly "gpt-5-mini": import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `openrouter:${keyof typeof openrouterModels}`;
+export declare const openrouterModelNames: ModelName[];
+export declare const openrouterProvider: {
+    openrouter: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "gpt-5" | "gpt-5-mini" | "gpt-4.1" | "deepseek-v3" | "deepseek-r1" | "deepseek-v3-free" | "deepseek-r1-free" | "gemini-flash25" | "gemini-pro25" | "sonnet4" | "opus4" | "opus-4.1" | "kimi-k2" | "kimi-k2-free" | "devstral-medium" | "qwen3-coder" | "qwen3-coder-free" | "glm-4.5"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const openrouterModelRegistry: {
+    [K in ModelName]: ModelMetadata<ModelName>;
+};
+export {};