@prometheus-ai/ai 0.5.0

package/dist/types/provider-models/openai-compat.d.ts

@@ -0,0 +1,323 @@
+import type { ModelManagerOptions } from "../model-manager";
+import type { Api, Model, Provider } from "../types";
+export interface ModelsDevModel {
+    id?: string;
+    name?: string;
+    tool_call?: boolean;
+    reasoning?: boolean;
+    limit?: {
+        context?: number;
+        output?: number;
+    };
+    cost?: {
+        input?: number;
+        output?: number;
+        cache_read?: number;
+        cache_write?: number;
+    };
+    modalities?: {
+        input?: string[];
+    };
+    status?: string;
+    provider?: {
+        npm?: string;
+    };
+}
+export interface OpenAIModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface GroqModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function groqModelManagerOptions(config?: GroqModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface CerebrasModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function cerebrasModelManagerOptions(config?: CerebrasModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface HuggingfaceModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function huggingfaceModelManagerOptions(config?: HuggingfaceModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface NvidiaModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function nvidiaModelManagerOptions(config?: NvidiaModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface XaiModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function xaiModelManagerOptions(config?: XaiModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface XaiOAuthModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+interface XAICuratedModel {
+    id: string;
+    contextWindow: number;
+    name?: string;
+    /** Whether the model reasons natively. Defaults to true for Grok-4.x family. */
+    reasoning?: boolean;
+    /**
+     * Whether xAI accepts the `reasoning.effort` wire param for this model.
+     * Default true. When false: picker hides the effort dial (via
+     * getSupportedEfforts in model-thinking.ts) AND wire-side already omits
+     * the param via GROK_EFFORT_CAPABLE_PREFIXES in providers/xai-responses.ts.
+     * Must agree with that allowlist; two truths kept in sync by curated-catalog
+     * author convention until a follow-up Op: compress unifies them.
+     */
+    supportsReasoningEffort?: boolean;
+    /**
+     * Input modalities this model accepts. Defaults to `["text"]` when absent.
+     * Vision-capable Grok models MUST list `"image"` here so the curated layer
+     * overrides `fetchOpenAICompatibleModels`' default of `["text"]` (which
+     * otherwise strips image capability on every online refresh).
+     */
+    input?: ("text" | "image")[];
+}
+export declare const XAI_OAUTH_CURATED_MODELS: readonly XAICuratedModel[];
+/**
+ * Render `XAI_OAUTH_CURATED_MODELS` as full `Model<"openai-responses">` entries.
+ *
+ * Single source of truth for the curated to Model fan-in, consumed by both
+ * - {@link xaiOAuthModelManagerOptions} (runtime static seed handed to the model
+ *   manager so the picker is populated on a fresh login), and
+ * - `packages/ai/scripts/generate-models.ts` (bundles the same entries into
+ *   `models.json`, so the synchronous `ModelRegistry.#loadModels()` boot path
+ *   sees `xai-oauth` without waiting for a refresh — fixes the boot-time
+ *   default-model reset when `modelRoles.default = "xai-oauth/<id>"`).
+ *
+ * `reasoning` defaults to `true` for the Grok-4.x family; the explicit
+ * `grok-4.20-0309-non-reasoning` entry opts out via `XAICuratedModel.reasoning`.
+ * `maxTokens` uses `UNK_MAX_TOKENS` so id-keyed overlays from a successful
+ * dynamic fetch merge cleanly. Mirrors
+ * `hermes-agent/hermes_cli/models.py:_XAI_STATIC_FALLBACK`.
+ */
+export declare function buildXaiOAuthStaticSeed(baseUrl?: string): Model<"openai-responses">[];
+export declare function xaiOAuthModelManagerOptions(config?: XaiOAuthModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface DeepSeekModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function deepseekModelManagerOptions(config?: DeepSeekModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface ZhipuCodingPlanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function zhipuCodingPlanModelManagerOptions(config?: ZhipuCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+/**
+ * Fireworks-published cap for the Kimi K2 family. Fireworks' `/v1/models`
+ * envelope generically reports `max_completion_tokens: 65536` for every Kimi
+ * deployment, but Kimi K2 (instruct / thinking / turbo) on Fireworks is
+ * documented to ship long reasoning traces that should be bounded — capping
+ * at 32,768 prevents handing callers a budget the router cannot honor.
+ * See https://github.com/uttamtrivedi/Prometheus/issues/1849.
+ */
+export declare const FIREWORKS_KIMI_MAX_TOKENS = 32768;
+/**
+ * Returns true for any Kimi K2.x public model id served by Fireworks-backed
+ * providers (`fireworks` direct, `firepass` router). Matches both the public
+ * catalog id (`kimi-k2.5`, `kimi-k2.6`, `kimi-k2.6-turbo`) and the canonical
+ * Fireworks wire id (`accounts/fireworks/{models,routers}/kimi-k2…`).
+ */
+export declare function isFireworksKimiK2ModelId(modelId: string): boolean;
+/**
+ * Clamp the Kimi K2 family's `maxTokens` to {@link FIREWORKS_KIMI_MAX_TOKENS}
+ * on Fireworks-backed providers, leaving every other model untouched.
+ */
+export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number): number;
+export interface FireworksModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function fireworksModelManagerOptions(config?: FireworksModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface FirepassModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+/**
+ * Fire Pass is a Fireworks subscription product that exposes a single router
+ * model (Kimi K2.6 Turbo) under `accounts/fireworks/routers/kimi-k2p6-turbo`.
+ * The dedicated `fpk_…` keys do not authorize `/v1/models`, so this manager
+ * never performs dynamic discovery — the bundled catalog entry is canonical.
+ * See https://docs.fireworks.ai/firepass.
+ */
+export declare function firepassModelManagerOptions(_config?: FirepassModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface WaferModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function waferPassModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function waferServerlessModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface MistralModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function mistralModelManagerOptions(config?: MistralModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface OpenCodeModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
+export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
+export interface OllamaModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function ollamaModelManagerOptions(config?: OllamaModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export interface OpenRouterModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface ZenMuxModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function zenmuxModelManagerOptions(config?: ZenMuxModelManagerConfig): ModelManagerOptions<Api>;
+export interface KiloModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function kiloModelManagerOptions(config?: KiloModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface AlibabaCodingPlanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function alibabaCodingPlanModelManagerOptions(config?: AlibabaCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VercelAiGatewayModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function vercelAiGatewayModelManagerOptions(config?: VercelAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+export interface KimiCodeModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function kimiCodeModelManagerOptions(config?: KimiCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface LmStudioModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function lmStudioModelManagerOptions(config?: LmStudioModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface SyntheticModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function syntheticModelManagerOptions(config?: SyntheticModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VeniceModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function veniceModelManagerOptions(config?: VeniceModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface TogetherModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function togetherModelManagerOptions(config?: TogetherModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface MoonshotModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function moonshotModelManagerOptions(config?: MoonshotModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface QwenPortalModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function qwenPortalModelManagerOptions(config?: QwenPortalModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface QianfanModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function qianfanModelManagerOptions(config?: QianfanModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface CloudflareAiGatewayModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function cloudflareAiGatewayModelManagerOptions(config?: CloudflareAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+/** Region codes for Xiaomi Token Plan clusters exposed as separate login providers. */
+export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
+/** Configures Xiaomi standard or regional Token Plan OpenAI-compatible model discovery. */
+export interface XiaomiModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    providerId?: Provider;
+    tokenPlanRegion?: XiaomiTokenPlanRegion;
+}
+/** Builds a Xiaomi model manager, preserving Token Plan region provider ids during discovery. */
+export declare function xiaomiModelManagerOptions(config?: XiaomiModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface LiteLLMModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function litellmModelManagerOptions(config?: LiteLLMModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface VllmModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function vllmModelManagerOptions(config?: VllmModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface NanoGptModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function nanoGptModelManagerOptions(config?: NanoGptModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export interface GithubCopilotModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function githubCopilotModelManagerOptions(config?: GithubCopilotModelManagerConfig): ModelManagerOptions<Api>;
+export interface AnthropicModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function anthropicModelManagerOptions(config?: AnthropicModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+export declare const UNK_CONTEXT_WINDOW = 222222;
+export declare const UNK_MAX_TOKENS = 8888;
+/** Describes how to map models.dev API data for a single provider. */
+export interface ModelsDevProviderDescriptor {
+    /** Key in the models.dev API response JSON (e.g., "anthropic", "amazon-bedrock") */
+    modelsDevKey: string;
+    /** Provider ID in our system */
+    providerId: string;
+    /** Default API type for this provider's models */
+    api: Api;
+    /** Default base URL */
+    baseUrl: string;
+    /** Default context window fallback (default: UNKNNOWN_CONTEXT_WINDOW) */
+    defaultContextWindow?: number;
+    /** Default max tokens fallback (default: UNKNNOWN_MAX_TOKENS) */
+    defaultMaxTokens?: number;
+    /** Optional compat overrides applied to every model from this provider */
+    compat?: Model<Api>["compat"];
+    /** Optional static headers applied to every model */
+    headers?: Record<string, string>;
+    /**
+     * Optional filter: return false to skip a model.
+     * Called with (modelId, rawModel). Default: skip if tool_call !== true.
+     */
+    filterModel?: (modelId: string, model: ModelsDevModel) => boolean;
+    /**
+     * Optional transform: modify the mapped model before it's added.
+     * Can return null to skip the model, or an array to emit multiple models.
+     */
+    transformModel?: (model: Model<Api>, modelId: string, raw: ModelsDevModel) => Model<Api> | Model<Api>[] | null;
+    /**
+     * Optional: override the API type per-model.
+     * Called with (modelId, raw). Return the API type to use.
+     * If not provided, uses the `api` field.
+     */
+    resolveApi?: (modelId: string, raw: ModelsDevModel) => {
+        api: Api;
+        baseUrl: string;
+    } | null;
+}
+/** Generic mapper that converts models.dev data using provider descriptors. */
+export declare function mapModelsDevToModels(data: Record<string, unknown>, descriptors: readonly ModelsDevProviderDescriptor[]): Model<Api>[];
+/** All provider descriptors for models.dev data mapping in generate-models.ts. */
+export declare const MODELS_DEV_PROVIDER_DESCRIPTORS: readonly ModelsDevProviderDescriptor[];
+export {};

package/dist/types/provider-models/special.d.ts

@@ -0,0 +1,16 @@
+import type { ModelManagerOptions } from "../model-manager";
+export interface OpenAICodexModelManagerConfig {
+    accessToken?: string;
+    accountId?: string;
+    clientVersion?: string;
+}
+export declare function openaiCodexModelManagerOptions(config?: OpenAICodexModelManagerConfig): ModelManagerOptions<"openai-codex-responses">;
+export interface CursorModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    clientVersion?: string;
+}
+export declare function cursorModelManagerOptions(config?: CursorModelManagerConfig): ModelManagerOptions<"cursor-agent">;
+export interface ZaiModelManagerConfig {
+}
+export declare function zaiModelManagerOptions(_config?: ZaiModelManagerConfig): ModelManagerOptions<"anthropic-messages">;

package/dist/types/providers/amazon-bedrock.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Amazon Bedrock Converse Stream provider.
+ *
+ * Talks directly to `bedrock-runtime.{region}.amazonaws.com` over HTTPS with
+ * SigV4 signing and decodes the `application/vnd.amazon.eventstream` response.
+ * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
+ * Bun's native `HTTPS_PROXY` support.
+ */
+import type { Effort } from "../model-thinking";
+import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types";
+export type BedrockThinkingDisplay = "summarized" | "omitted";
+export interface BedrockOptions extends StreamOptions {
+    region?: string;
+    profile?: string;
+    /** Amazon Bedrock API key sent as `Authorization: Bearer`, ahead of SigV4 credential resolution. */
+    bearerToken?: string;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    reasoning?: Effort;
+    thinkingBudgets?: ThinkingBudgets;
+    interleavedThinking?: boolean;
+    /**
+     * Controls how Claude returns thinking content in Bedrock responses.
+     * - `"summarized"`: thinking blocks include human-readable summaries (default here).
+     * - `"omitted"`: thinking content is suppressed; the encrypted signature still
+     *   travels back for multi-turn continuity.
+     *
+     * Starting with Claude Opus 4.7 the Anthropic API default is `"omitted"`, which
+     * leaves callers waiting on a silent stream during long reasoning runs (issue
+     * #1373). We default to `"summarized"` so adaptive-thinking models that accept
+     * the field keep producing visible thinking deltas. Older adaptive-thinking
+     * models (Opus 4.6, Sonnet 4.6+) reject the field, so we omit it for them.
+     */
+    thinkingDisplay?: BedrockThinkingDisplay;
+}
+export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;

package/dist/types/providers/anthropic-client.d.ts

@@ -0,0 +1,99 @@
+import type { FetchImpl } from "../types";
+import type { MessageCreateParamsStreaming } from "./anthropic-wire";
+/** Per-request options accepted by {@link AnthropicMessages.create}. */
+export interface AnthropicRequestOptions {
+    signal?: AbortSignal;
+    /** Pre-response timeout in milliseconds. */
+    timeout?: number;
+    /** Per-request retry budget override. */
+    maxRetries?: number;
+}
+/**
+ * Extra `RequestInit` fields merged into every fetch call. Bun extends
+ * `RequestInit` with a `tls` option used for the Claude Code TLS profile and
+ * Foundry mTLS.
+ */
+export type AnthropicFetchOptions = RequestInit & {
+    tls?: {
+        rejectUnauthorized?: boolean;
+        serverName?: string;
+        ciphers?: string;
+        ca?: string | string[];
+        cert?: string;
+        key?: string;
+    };
+};
+export interface AnthropicClientOptions {
+    /** Sent as `X-Api-Key` unless the header is already present in `defaultHeaders`. */
+    apiKey?: string | null;
+    /** Sent as `Authorization: Bearer <token>` unless the header is already present in `defaultHeaders`. */
+    authToken?: string | null;
+    baseURL?: string | null;
+    maxRetries?: number;
+    /** Pre-response timeout in milliseconds. Defaults to 10 minutes. */
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    fetch?: FetchImpl;
+    fetchOptions?: AnthropicFetchOptions;
+}
+/** Non-2xx response from the Anthropic API. */
+export declare class AnthropicApiError extends Error {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly requestId: string | null;
+    constructor(status: number, message: string, headers: Headers);
+    static fromResponse(response: Response): Promise<AnthropicApiError>;
+}
+/** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
+export declare class AnthropicConnectionError extends Error {
+    constructor(cause: unknown);
+}
+/** No response headers arrived within the configured request timeout. */
+export declare class AnthropicConnectionTimeoutError extends Error {
+    constructor();
+}
+/**
+ * Lazy in-flight request handle. The HTTP request starts on the first
+ * `asResponse()` call; subsequent calls return the same promise.
+ *
+ * Shape-compatible with the SDK's `APIPromise.asResponse()` so
+ * `getAnthropicStreamResponse` treats internal and injected clients uniformly.
+ */
+export declare class AnthropicApiRequest {
+    #private;
+    constructor(start: () => Promise<Response>);
+    asResponse(): Promise<Response>;
+}
+/**
+ * `messages` resource. `create` lives on the prototype so tests can intercept
+ * every outgoing request with `vi.spyOn(AnthropicMessages.prototype, "create")`.
+ */
+export declare class AnthropicMessages {
+    #private;
+    constructor(client: AnthropicMessagesClient, path: string);
+    create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}
+/**
+ * Structural interface satisfied by both {@link AnthropicMessagesClient} and
+ * SDK-style clients (e.g. `AnthropicVertex`), so callers can inject an
+ * alternative Messages-API client via `AnthropicOptions.client`.
+ */
+export interface AnthropicMessagesClientLike {
+    messages: {
+        create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+    };
+    beta?: {
+        messages: {
+            create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+        };
+    };
+}
+export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
+    #private;
+    readonly messages: AnthropicMessages;
+    readonly beta: {
+        readonly messages: AnthropicMessages;
+    };
+    constructor(options: AnthropicClientOptions);
+    request(path: string, params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}