@providerprotocol/ai 0.0.2 → 0.0.3

package/dist/openrouter/index.d.ts

@@ -0,0 +1,235 @@
+import { b as Provider, M as ModelReference, a as LLMHandler } from '../provider-CUJWjgNl.js';
+
+/**
+ * OpenRouter-specific LLM parameters
+ * These are passed through to the OpenRouter APIs
+ */
+interface OpenRouterLLMParams {
+    /** Maximum number of tokens to generate */
+    max_tokens?: number;
+    /** Maximum output tokens (Responses API) */
+    max_output_tokens?: number;
+    /** Temperature for randomness (0.0 - 2.0) */
+    temperature?: number;
+    /** Top-p (nucleus) sampling (0.0 - 1.0) */
+    top_p?: number;
+    /** Top-k sampling (not available for OpenAI models) */
+    top_k?: number;
+    /** Frequency penalty (-2.0 - 2.0) */
+    frequency_penalty?: number;
+    /** Presence penalty (-2.0 - 2.0) */
+    presence_penalty?: number;
+    /** Repetition penalty (0.0 - 2.0) */
+    repetition_penalty?: number;
+    /** Custom stop sequences */
+    stop?: string | string[];
+    /** Seed for deterministic sampling */
+    seed?: number;
+    /** User identifier for abuse detection */
+    user?: string;
+    /** Enable logprobs */
+    logprobs?: boolean;
+    /** Number of top logprobs to return */
+    top_logprobs?: number;
+    /** Logit bias map */
+    logit_bias?: Record<number, number>;
+    /** Minimum probability threshold (0.0 - 1.0) */
+    min_p?: number;
+    /** Top-a sampling threshold (0.0 - 1.0) */
+    top_a?: number;
+    /** Whether to enable parallel tool calls */
+    parallel_tool_calls?: boolean;
+    /** Response format for structured output (Chat Completions API only) */
+    response_format?: OpenRouterResponseFormat;
+    /**
+     * Prompt transforms to apply
+     * See: https://openrouter.ai/docs/guides/features/message-transforms
+     */
+    transforms?: string[];
+    /**
+     * Multiple models for routing
+     * See: https://openrouter.ai/docs/guides/features/model-routing
+     */
+    models?: string[];
+    /**
+     * Routing strategy (e.g., 'fallback')
+     */
+    route?: 'fallback';
+    /**
+     * Provider routing preferences
+     * See: https://openrouter.ai/docs/guides/routing/provider-selection
+     */
+    provider?: OpenRouterProviderPreferences;
+    /**
+     * Predicted output for latency optimization
+     * https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs
+     */
+    prediction?: {
+        type: 'content';
+        content: string;
+    };
+    /**
+     * Debug options (streaming only)
+     */
+    debug?: {
+        /** If true, returns the transformed request body sent to the provider */
+        echo_upstream_body?: boolean;
+    };
+    /**
+     * Reasoning configuration (Responses API)
+     */
+    reasoning?: {
+        effort?: 'low' | 'medium' | 'high';
+    };
+}
+/**
+ * API mode for OpenRouter provider
+ */
+type OpenRouterAPIMode = 'completions' | 'responses';
+/**
+ * Model options when creating a model reference
+ */
+interface OpenRouterModelOptions {
+    /** Which API to use */
+    api?: OpenRouterAPIMode;
+}
+/**
+ * Model reference with OpenRouter-specific options
+ */
+interface OpenRouterModelReference {
+    modelId: string;
+    options?: OpenRouterModelOptions;
+}
+/**
+ * OpenRouter provider configuration
+ */
+interface OpenRouterConfig {
+    /** Which API to use: 'completions' (default) or 'responses' (beta) */
+    api?: 'completions' | 'responses';
+}
+/**
+ * Provider routing preferences
+ */
+interface OpenRouterProviderPreferences {
+    /** Allow fallback to other providers */
+    allow_fallbacks?: boolean;
+    /** Require specific parameters to be supported */
+    require_parameters?: boolean;
+    /** Data collection policy */
+    data_collection?: 'allow' | 'deny';
+    /** Order of provider preference */
+    order?: string[];
+    /** Ignore specific providers */
+    ignore?: string[];
+    /** Quantization preferences */
+    quantizations?: string[];
+}
+/**
+ * Response format
+ */
+type OpenRouterResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+
+/**
+ * OpenRouter provider options
+ */
+interface OpenRouterProviderOptions {
+    /**
+     * Which API to use:
+     * - 'completions': Chat Completions API (default, recommended)
+     * - 'responses': Responses API (beta)
+     */
+    api?: 'completions' | 'responses';
+}
+/**
+ * OpenRouter provider with configurable API mode
+ *
+ * @example
+ * // Using the Chat Completions API (default)
+ * const model = openrouter('openai/gpt-4o');
+ *
+ * @example
+ * // Using the Responses API (beta)
+ * const model = openrouter('openai/gpt-4o', { api: 'responses' });
+ *
+ * @example
+ * // Explicit Completions API
+ * const model = openrouter('anthropic/claude-3.5-sonnet', { api: 'completions' });
+ */
+interface OpenRouterProvider extends Provider<OpenRouterProviderOptions> {
+    /**
+     * Create a model reference
+     * @param modelId - The model identifier (e.g., 'openai/gpt-4o', 'anthropic/claude-3.5-sonnet', 'meta-llama/llama-3.1-70b-instruct')
+     * @param options - Provider options including API selection
+     */
+    (modelId: string, options?: OpenRouterProviderOptions): ModelReference<OpenRouterProviderOptions>;
+    /** Provider name */
+    readonly name: 'openrouter';
+    /** Provider version */
+    readonly version: string;
+    /** Supported modalities */
+    readonly modalities: {
+        llm: LLMHandler<OpenRouterLLMParams>;
+    };
+}
+/**
+ * OpenRouter provider
+ *
+ * Supports both the Chat Completions API (default) and Responses API (beta).
+ *
+ * OpenRouter is a unified API that provides access to hundreds of AI models
+ * through a single endpoint, including models from OpenAI, Anthropic, Google,
+ * Meta, Mistral, and many others.
+ *
+ * @example
+ * ```ts
+ * import { openrouter } from './providers/openrouter';
+ * import { llm } from './core/llm';
+ *
+ * // Using Chat Completions API (default, recommended)
+ * const model = llm({
+ *   model: openrouter('openai/gpt-4o'),
+ *   params: { max_tokens: 1000 }
+ * });
+ *
+ * // Using Responses API (beta)
+ * const betaModel = llm({
+ *   model: openrouter('openai/gpt-4o', { api: 'responses' }),
+ *   params: { max_output_tokens: 1000 }
+ * });
+ *
+ * // Using OpenRouter-specific features
+ * const routedModel = llm({
+ *   model: openrouter('openai/gpt-4o'),
+ *   params: {
+ *     max_tokens: 1000,
+ *     // Fallback routing
+ *     models: ['openai/gpt-4o', 'anthropic/claude-3.5-sonnet'],
+ *     route: 'fallback',
+ *     // Provider preferences
+ *     provider: {
+ *       allow_fallbacks: true,
+ *       require_parameters: true,
+ *     },
+ *   }
+ * });
+ *
+ * // Generate
+ * const turn = await model.generate('Hello!');
+ * console.log(turn.response.text);
+ * ```
+ */
+declare const openrouter: OpenRouterProvider;
+
+export { type OpenRouterAPIMode, type OpenRouterConfig, type OpenRouterLLMParams, type OpenRouterModelOptions, type OpenRouterModelReference, type OpenRouterProviderPreferences, openrouter };