@providerprotocol/ai 0.0.4 → 0.0.6

package/src/providers/openai/llm.completions.ts

@@ -6,7 +6,7 @@ import { resolveApiKey } from '../../http/keys.ts';
 import { doFetch, doStreamFetch } from '../../http/fetch.ts';
 import { parseSSEStream } from '../../http/sse.ts';
 import { normalizeHttpError } from '../../http/errors.ts';
-import type { OpenAILLMParams, OpenAICompletionsResponse, OpenAICompletionsStreamChunk } from './types.ts';
+import type { OpenAICompletionsParams, OpenAICompletionsResponse, OpenAICompletionsStreamChunk } from './types.ts';
 import {
   transformRequest,
   transformResponse,
@@ -32,16 +32,16 @@ const OPENAI_CAPABILITIES: LLMCapabilities = {
 /**
  * Create OpenAI Chat Completions LLM handler
  */
-export function createCompletionsLLMHandler(): LLMHandler<OpenAILLMParams> {
+export function createCompletionsLLMHandler(): LLMHandler<OpenAICompletionsParams> {
   // Provider reference injected by createProvider() or OpenAI's custom factory
-  let providerRef: LLMProvider<OpenAILLMParams> | null = null;
+  let providerRef: LLMProvider<OpenAICompletionsParams> | null = null;
 
   return {
-    _setProvider(provider: LLMProvider<OpenAILLMParams>) {
+    _setProvider(provider: LLMProvider<OpenAICompletionsParams>) {
       providerRef = provider;
     },
 
-    bind(modelId: string): BoundLLMModel<OpenAILLMParams> {
+    bind(modelId: string): BoundLLMModel<OpenAICompletionsParams> {
       // Use the injected provider reference
       if (!providerRef) {
         throw new UPPError(
@@ -52,15 +52,15 @@ export function createCompletionsLLMHandler(): LLMHandler<OpenAILLMParams> {
         );
       }
 
-      const model: BoundLLMModel<OpenAILLMParams> = {
+      const model: BoundLLMModel<OpenAICompletionsParams> = {
         modelId,
         capabilities: OPENAI_CAPABILITIES,
 
-        get provider(): LLMProvider<OpenAILLMParams> {
+        get provider(): LLMProvider<OpenAICompletionsParams> {
           return providerRef!;
         },
 
-        async complete(request: LLMRequest<OpenAILLMParams>): Promise<LLMResponse> {
+        async complete(request: LLMRequest<OpenAICompletionsParams>): Promise<LLMResponse> {
           const apiKey = await resolveApiKey(
             request.config,
             'OPENAI_API_KEY',
@@ -91,7 +91,7 @@ export function createCompletionsLLMHandler(): LLMHandler<OpenAILLMParams> {
           return transformResponse(data);
         },
 
-        stream(request: LLMRequest<OpenAILLMParams>): LLMStreamResult {
+        stream(request: LLMRequest<OpenAICompletionsParams>): LLMStreamResult {
           const state = createStreamState();
           let responseResolve: (value: LLMResponse) => void;
           let responseReject: (error: Error) => void;

package/src/providers/openai/llm.responses.ts

@@ -6,7 +6,7 @@ import { resolveApiKey } from '../../http/keys.ts';
 import { doFetch, doStreamFetch } from '../../http/fetch.ts';
 import { parseSSEStream } from '../../http/sse.ts';
 import { normalizeHttpError } from '../../http/errors.ts';
-import type { OpenAILLMParams, OpenAIResponsesResponse, OpenAIResponsesStreamEvent, OpenAIResponseErrorEvent } from './types.ts';
+import type { OpenAIResponsesParams, OpenAIResponsesResponse, OpenAIResponsesStreamEvent, OpenAIResponseErrorEvent } from './types.ts';
 import {
   transformRequest,
   transformResponse,
@@ -32,16 +32,16 @@ const OPENAI_CAPABILITIES: LLMCapabilities = {
 /**
  * Create OpenAI Responses API LLM handler
  */
-export function createResponsesLLMHandler(): LLMHandler<OpenAILLMParams> {
+export function createResponsesLLMHandler(): LLMHandler<OpenAIResponsesParams> {
   // Provider reference injected by createProvider() or OpenAI's custom factory
-  let providerRef: LLMProvider<OpenAILLMParams> | null = null;
+  let providerRef: LLMProvider<OpenAIResponsesParams> | null = null;
 
   return {
-    _setProvider(provider: LLMProvider<OpenAILLMParams>) {
+    _setProvider(provider: LLMProvider<OpenAIResponsesParams>) {
       providerRef = provider;
     },
 
-    bind(modelId: string): BoundLLMModel<OpenAILLMParams> {
+    bind(modelId: string): BoundLLMModel<OpenAIResponsesParams> {
       // Use the injected provider reference
       if (!providerRef) {
         throw new UPPError(
@@ -52,15 +52,15 @@ export function createResponsesLLMHandler(): LLMHandler<OpenAILLMParams> {
         );
       }
 
-      const model: BoundLLMModel<OpenAILLMParams> = {
+      const model: BoundLLMModel<OpenAIResponsesParams> = {
         modelId,
         capabilities: OPENAI_CAPABILITIES,
 
-        get provider(): LLMProvider<OpenAILLMParams> {
+        get provider(): LLMProvider<OpenAIResponsesParams> {
           return providerRef!;
         },
 
-        async complete(request: LLMRequest<OpenAILLMParams>): Promise<LLMResponse> {
+        async complete(request: LLMRequest<OpenAIResponsesParams>): Promise<LLMResponse> {
           const apiKey = await resolveApiKey(
             request.config,
             'OPENAI_API_KEY',
@@ -102,7 +102,7 @@ export function createResponsesLLMHandler(): LLMHandler<OpenAILLMParams> {
           return transformResponse(data);
         },
 
-        stream(request: LLMRequest<OpenAILLMParams>): LLMStreamResult {
+        stream(request: LLMRequest<OpenAIResponsesParams>): LLMStreamResult {
           const state = createStreamState();
           let responseResolve: (value: LLMResponse) => void;
           let responseReject: (error: Error) => void;

package/src/providers/openai/transform.completions.ts

@@ -11,7 +11,7 @@ import {
   isToolResultMessage,
 } from '../../types/messages.ts';
 import type {
-  OpenAILLMParams,
+  OpenAICompletionsParams,
   OpenAICompletionsRequest,
   OpenAICompletionsMessage,
   OpenAIUserContent,
@@ -23,94 +23,30 @@ import type {
 
 /**
  * Transform UPP request to OpenAI Chat Completions format
+ *
+ * Params are spread directly to allow pass-through of any OpenAI API fields,
+ * even those not explicitly defined in our type. This enables developers to
+ * use new API features without waiting for library updates.
  */
-export function transformRequest<TParams extends OpenAILLMParams>(
-  request: LLMRequest<TParams>,
+export function transformRequest(
+  request: LLMRequest<OpenAICompletionsParams>,
   modelId: string
 ): OpenAICompletionsRequest {
-  const params: OpenAILLMParams = request.params ?? {};
+  const params = request.params ?? ({} as OpenAICompletionsParams);
 
+  // Spread params to pass through all fields, then set required fields
   const openaiRequest: OpenAICompletionsRequest = {
+    ...params,
     model: modelId,
     messages: transformMessages(request.messages, request.system),
   };
 
-  // Model parameters
-  if (params.temperature !== undefined) {
-    openaiRequest.temperature = params.temperature;
-  }
-  if (params.top_p !== undefined) {
-    openaiRequest.top_p = params.top_p;
-  }
-  if (params.max_completion_tokens !== undefined) {
-    openaiRequest.max_completion_tokens = params.max_completion_tokens;
-  } else if (params.max_tokens !== undefined) {
-    openaiRequest.max_tokens = params.max_tokens;
-  }
-  if (params.frequency_penalty !== undefined) {
-    openaiRequest.frequency_penalty = params.frequency_penalty;
-  }
-  if (params.presence_penalty !== undefined) {
-    openaiRequest.presence_penalty = params.presence_penalty;
-  }
-  if (params.stop !== undefined) {
-    openaiRequest.stop = params.stop;
-  }
-  if (params.n !== undefined) {
-    openaiRequest.n = params.n;
-  }
-  if (params.logprobs !== undefined) {
-    openaiRequest.logprobs = params.logprobs;
-  }
-  if (params.top_logprobs !== undefined) {
-    openaiRequest.top_logprobs = params.top_logprobs;
-  }
-  if (params.seed !== undefined) {
-    openaiRequest.seed = params.seed;
-  }
-  if (params.user !== undefined) {
-    openaiRequest.user = params.user;
-  }
-  if (params.logit_bias !== undefined) {
-    openaiRequest.logit_bias = params.logit_bias;
-  }
-  if (params.reasoning_effort !== undefined) {
-    openaiRequest.reasoning_effort = params.reasoning_effort;
-  }
-  if (params.verbosity !== undefined) {
-    openaiRequest.verbosity = params.verbosity;
-  }
-  if (params.service_tier !== undefined) {
-    openaiRequest.service_tier = params.service_tier;
-  }
-  if (params.store !== undefined) {
-    openaiRequest.store = params.store;
-  }
-  if (params.metadata !== undefined) {
-    openaiRequest.metadata = params.metadata;
-  }
-  if (params.prediction !== undefined) {
-    openaiRequest.prediction = params.prediction;
-  }
-  if (params.prompt_cache_key !== undefined) {
-    openaiRequest.prompt_cache_key = params.prompt_cache_key;
-  }
-  if (params.prompt_cache_retention !== undefined) {
-    openaiRequest.prompt_cache_retention = params.prompt_cache_retention;
-  }
-  if (params.safety_identifier !== undefined) {
-    openaiRequest.safety_identifier = params.safety_identifier;
-  }
-
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     openaiRequest.tools = request.tools.map(transformTool);
-    if (params.parallel_tool_calls !== undefined) {
-      openaiRequest.parallel_tool_calls = params.parallel_tool_calls;
-    }
   }
 
-  // Structured output via response_format
+  // Structured output via response_format (overrides params.response_format if set)
   if (request.structure) {
     const schema: Record<string, unknown> = {
       type: 'object',
@@ -133,9 +69,6 @@ export function transformRequest<TParams extends OpenAILLMParams>(
         strict: true,
       },
     };
-  } else if (params.response_format !== undefined) {
-    // Pass through response_format from params if no structure is defined
-    openaiRequest.response_format = params.response_format;
   }
 
   return openaiRequest;

package/src/providers/openai/transform.responses.ts

@@ -11,7 +11,7 @@ import {
   isToolResultMessage,
 } from '../../types/messages.ts';
 import type {
-  OpenAILLMParams,
+  OpenAIResponsesParams,
   OpenAIResponsesRequest,
   OpenAIResponsesInputItem,
   OpenAIResponsesContentPart,
@@ -25,72 +25,30 @@ import type {
 
 /**
  * Transform UPP request to OpenAI Responses API format
+ *
+ * Params are spread directly to allow pass-through of any OpenAI API fields,
+ * even those not explicitly defined in our type. This enables developers to
+ * use new API features without waiting for library updates.
  */
-export function transformRequest<TParams extends OpenAILLMParams>(
-  request: LLMRequest<TParams>,
+export function transformRequest(
+  request: LLMRequest<OpenAIResponsesParams>,
   modelId: string
 ): OpenAIResponsesRequest {
-  const params: OpenAILLMParams = request.params ?? {};
+  const params = request.params ?? ({} as OpenAIResponsesParams);
 
+  // Spread params to pass through all fields, then set required fields
   const openaiRequest: OpenAIResponsesRequest = {
+    ...params,
     model: modelId,
     input: transformInputItems(request.messages, request.system),
   };
 
-  // Model parameters
-  if (params.temperature !== undefined) {
-    openaiRequest.temperature = params.temperature;
-  }
-  if (params.top_p !== undefined) {
-    openaiRequest.top_p = params.top_p;
-  }
-  if (params.max_output_tokens !== undefined) {
-    openaiRequest.max_output_tokens = params.max_output_tokens;
-  } else if (params.max_completion_tokens !== undefined) {
-    openaiRequest.max_output_tokens = params.max_completion_tokens;
-  } else if (params.max_tokens !== undefined) {
-    openaiRequest.max_output_tokens = params.max_tokens;
-  }
-  if (params.service_tier !== undefined) {
-    openaiRequest.service_tier = params.service_tier;
-  }
-  if (params.store !== undefined) {
-    openaiRequest.store = params.store;
-  }
-  if (params.metadata !== undefined) {
-    openaiRequest.metadata = params.metadata;
-  }
-  if (params.truncation !== undefined) {
-    openaiRequest.truncation = params.truncation;
-  }
-  if (params.include !== undefined) {
-    openaiRequest.include = params.include;
-  }
-  if (params.background !== undefined) {
-    openaiRequest.background = params.background;
-  }
-  if (params.previous_response_id !== undefined) {
-    openaiRequest.previous_response_id = params.previous_response_id;
-  }
-  if (params.reasoning !== undefined) {
-    openaiRequest.reasoning = { ...params.reasoning };
-  }
-  if (params.reasoning_effort !== undefined) {
-    openaiRequest.reasoning = {
-      ...(openaiRequest.reasoning ?? {}),
-      effort: params.reasoning_effort,
-    };
-  }
-
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     openaiRequest.tools = request.tools.map(transformTool);
-    if (params.parallel_tool_calls !== undefined) {
-      openaiRequest.parallel_tool_calls = params.parallel_tool_calls;
-    }
   }
 
-  // Structured output via text.format
+  // Structured output via text.format (overrides params.text if set)
   if (request.structure) {
     const schema: Record<string, unknown> = {
       type: 'object',

package/src/providers/openai/types.ts

@@ -1,17 +1,14 @@
 /**
- * OpenAI-specific LLM parameters
- * These are passed through to the relevant OpenAI APIs
+ * OpenAI Chat Completions API parameters
+ * These are passed through to the /v1/chat/completions endpoint
  */
-export interface OpenAILLMParams {
-  /** Maximum number of tokens to generate */
+export interface OpenAICompletionsParams {
+  /** Maximum number of tokens to generate (legacy, prefer max_completion_tokens) */
   max_tokens?: number;
 
-  /** Maximum completion tokens (preferred over max_tokens for newer models) */
+  /** Maximum completion tokens (preferred for newer models) */
   max_completion_tokens?: number;
 
-  /** Maximum output tokens (Responses API) */
-  max_output_tokens?: number;
-
   /** Temperature for randomness (0.0 - 2.0) */
   temperature?: number;
 
@@ -42,10 +39,10 @@ export interface OpenAILLMParams {
   /** User identifier for abuse detection */
   user?: string;
 
-  /** Logit bias map (Chat Completions API) */
+  /** Logit bias map */
   logit_bias?: Record<string, number>;
 
-  /** Verbosity control (Chat Completions API) */
+  /** Verbosity control */
   verbosity?: 'low' | 'medium' | 'high';
 
   /** Whether to enable parallel tool calls */
@@ -54,40 +51,21 @@ export interface OpenAILLMParams {
   /** Reasoning effort for reasoning models */
   reasoning_effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
 
-  /** Reasoning configuration (Responses API) */
-  reasoning?: {
-    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-    summary?: string;
-  };
-
   /** Service tier */
   service_tier?: 'auto' | 'default' | 'flex' | 'priority';
 
-  /** Truncation strategy (Responses API) */
-  truncation?: 'auto' | 'disabled';
-
-  /** Fields to include in Responses API output */
-  include?: string[];
-
-  /** Background processing (Responses API) */
-  background?: boolean;
-
-  /** Continue from a previous response (Responses API) */
-  previous_response_id?: string;
-
   /** Store completion for distillation */
   store?: boolean;
 
   /** Metadata key-value pairs */
   metadata?: Record<string, string>;
 
-  /** Response format for structured output (Chat Completions API only) */
+  /** Response format for structured output */
   response_format?: OpenAIResponseFormat;
 
   /**
    * Predicted Output configuration for faster regeneration
    * Improves response times when large parts of the response are known ahead of time
-   * Most useful when regenerating a file with only minor changes
    */
   prediction?: {
     type: 'content';
@@ -95,7 +73,7 @@ export interface OpenAILLMParams {
   };
 
   /**
-   * Stable identifier for caching similar requests (replaces user field)
+   * Stable identifier for caching similar requests
    * Used to optimize cache hit rates
    */
   prompt_cache_key?: string;
@@ -113,6 +91,51 @@ export interface OpenAILLMParams {
   safety_identifier?: string;
 }
 
+/**
+ * OpenAI Responses API parameters
+ * These are passed through to the /v1/responses endpoint
+ */
+export interface OpenAIResponsesParams {
+  /** Maximum output tokens */
+  max_output_tokens?: number;
+
+  /** Temperature for randomness (0.0 - 2.0) */
+  temperature?: number;
+
+  /** Top-p (nucleus) sampling (0.0 - 1.0) */
+  top_p?: number;
+
+  /** Whether to enable parallel tool calls */
+  parallel_tool_calls?: boolean;
+
+  /** Reasoning configuration */
+  reasoning?: {
+    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    summary?: string;
+  };
+
+  /** Service tier */
+  service_tier?: 'auto' | 'default' | 'flex' | 'priority';
+
+  /** Truncation strategy */
+  truncation?: 'auto' | 'disabled';
+
+  /** Fields to include in output */
+  include?: string[];
+
+  /** Background processing */
+  background?: boolean;
+
+  /** Continue from a previous response */
+  previous_response_id?: string;
+
+  /** Store response for continuation */
+  store?: boolean;
+
+  /** Metadata key-value pairs */
+  metadata?: Record<string, string>;
+}
+
 /**
  * API mode for OpenAI provider
  */

package/src/providers/openrouter/index.ts

@@ -6,7 +6,10 @@ import type {
 } from '../../types/provider.ts';
 import { createCompletionsLLMHandler } from './llm.completions.ts';
 import { createResponsesLLMHandler } from './llm.responses.ts';
-import type { OpenRouterLLMParams, OpenRouterConfig } from './types.ts';
+import type { OpenRouterCompletionsParams, OpenRouterResponsesParams, OpenRouterConfig } from './types.ts';
+
+/** Union type for modalities interface */
+type OpenRouterLLMParamsUnion = OpenRouterCompletionsParams | OpenRouterResponsesParams;
 
 /**
  * OpenRouter provider options
@@ -51,7 +54,7 @@ export interface OpenRouterProvider extends Provider<OpenRouterProviderOptions>
 
   /** Supported modalities */
   readonly modalities: {
-    llm: LLMHandler<OpenRouterLLMParams>;
+    llm: LLMHandler<OpenRouterLLMParamsUnion>;
   };
 }
 
@@ -78,10 +81,10 @@ function createOpenRouterProvider(): OpenRouterProvider {
 
   // Create a dynamic modalities object that returns the correct handler
   const modalities = {
-    get llm(): LLMHandler<OpenRouterLLMParams> {
+    get llm(): LLMHandler<OpenRouterLLMParamsUnion> {
       return currentApiMode === 'responses'
-        ? responsesHandler
-        : completionsHandler;
+        ? (responsesHandler as unknown as LLMHandler<OpenRouterLLMParamsUnion>)
+        : (completionsHandler as unknown as LLMHandler<OpenRouterLLMParamsUnion>);
     },
   };
 
@@ -107,8 +110,8 @@ function createOpenRouterProvider(): OpenRouterProvider {
   const provider = fn as OpenRouterProvider;
 
   // Inject provider reference into both handlers (spec compliance)
-  completionsHandler._setProvider?.(provider as unknown as LLMProvider<OpenRouterLLMParams>);
-  responsesHandler._setProvider?.(provider as unknown as LLMProvider<OpenRouterLLMParams>);
+  completionsHandler._setProvider?.(provider as unknown as LLMProvider<OpenRouterCompletionsParams>);
+  responsesHandler._setProvider?.(provider as unknown as LLMProvider<OpenRouterResponsesParams>);
 
   return provider;
 }
@@ -164,7 +167,8 @@ export const openrouter = createOpenRouterProvider();
 
 // Re-export types
 export type {
-  OpenRouterLLMParams,
+  OpenRouterCompletionsParams,
+  OpenRouterResponsesParams,
   OpenRouterConfig,
   OpenRouterAPIMode,
   OpenRouterModelOptions,

package/src/providers/openrouter/llm.completions.ts

@@ -6,7 +6,7 @@ import { resolveApiKey } from '../../http/keys.ts';
 import { doFetch, doStreamFetch } from '../../http/fetch.ts';
 import { parseSSEStream } from '../../http/sse.ts';
 import { normalizeHttpError } from '../../http/errors.ts';
-import type { OpenRouterLLMParams, OpenRouterCompletionsResponse, OpenRouterCompletionsStreamChunk } from './types.ts';
+import type { OpenRouterCompletionsParams, OpenRouterCompletionsResponse, OpenRouterCompletionsStreamChunk } from './types.ts';
 import {
   transformRequest,
   transformResponse,
@@ -32,16 +32,16 @@ const OPENROUTER_CAPABILITIES: LLMCapabilities = {
 /**
  * Create OpenRouter Chat Completions LLM handler
  */
-export function createCompletionsLLMHandler(): LLMHandler<OpenRouterLLMParams> {
+export function createCompletionsLLMHandler(): LLMHandler<OpenRouterCompletionsParams> {
   // Provider reference injected by createProvider() or OpenRouter's custom factory
-  let providerRef: LLMProvider<OpenRouterLLMParams> | null = null;
+  let providerRef: LLMProvider<OpenRouterCompletionsParams> | null = null;
 
   return {
-    _setProvider(provider: LLMProvider<OpenRouterLLMParams>) {
+    _setProvider(provider: LLMProvider<OpenRouterCompletionsParams>) {
       providerRef = provider;
     },
 
-    bind(modelId: string): BoundLLMModel<OpenRouterLLMParams> {
+    bind(modelId: string): BoundLLMModel<OpenRouterCompletionsParams> {
       // Use the injected provider reference
       if (!providerRef) {
         throw new UPPError(
@@ -52,15 +52,15 @@ export function createCompletionsLLMHandler(): LLMHandler<OpenRouterLLMParams> {
         );
       }
 
-      const model: BoundLLMModel<OpenRouterLLMParams> = {
+      const model: BoundLLMModel<OpenRouterCompletionsParams> = {
         modelId,
         capabilities: OPENROUTER_CAPABILITIES,
 
-        get provider(): LLMProvider<OpenRouterLLMParams> {
+        get provider(): LLMProvider<OpenRouterCompletionsParams> {
           return providerRef!;
         },
 
-        async complete(request: LLMRequest<OpenRouterLLMParams>): Promise<LLMResponse> {
+        async complete(request: LLMRequest<OpenRouterCompletionsParams>): Promise<LLMResponse> {
           const apiKey = await resolveApiKey(
             request.config,
             'OPENROUTER_API_KEY',
@@ -91,7 +91,7 @@ export function createCompletionsLLMHandler(): LLMHandler<OpenRouterLLMParams> {
           return transformResponse(data);
         },
 
-        stream(request: LLMRequest<OpenRouterLLMParams>): LLMStreamResult {
+        stream(request: LLMRequest<OpenRouterCompletionsParams>): LLMStreamResult {
           const state = createStreamState();
           let responseResolve: (value: LLMResponse) => void;
           let responseReject: (error: Error) => void;

package/src/providers/openrouter/llm.responses.ts

@@ -6,7 +6,7 @@ import { resolveApiKey } from '../../http/keys.ts';
 import { doFetch, doStreamFetch } from '../../http/fetch.ts';
 import { parseSSEStream } from '../../http/sse.ts';
 import { normalizeHttpError } from '../../http/errors.ts';
-import type { OpenRouterLLMParams, OpenRouterResponsesResponse, OpenRouterResponsesStreamEvent, OpenRouterResponseErrorEvent } from './types.ts';
+import type { OpenRouterResponsesParams, OpenRouterResponsesResponse, OpenRouterResponsesStreamEvent, OpenRouterResponseErrorEvent } from './types.ts';
 import {
   transformRequest,
   transformResponse,
@@ -32,16 +32,16 @@ const OPENROUTER_CAPABILITIES: LLMCapabilities = {
 /**
  * Create OpenRouter Responses API LLM handler
  */
-export function createResponsesLLMHandler(): LLMHandler<OpenRouterLLMParams> {
+export function createResponsesLLMHandler(): LLMHandler<OpenRouterResponsesParams> {
   // Provider reference injected by createProvider() or OpenRouter's custom factory
-  let providerRef: LLMProvider<OpenRouterLLMParams> | null = null;
+  let providerRef: LLMProvider<OpenRouterResponsesParams> | null = null;
 
   return {
-    _setProvider(provider: LLMProvider<OpenRouterLLMParams>) {
+    _setProvider(provider: LLMProvider<OpenRouterResponsesParams>) {
       providerRef = provider;
     },
 
-    bind(modelId: string): BoundLLMModel<OpenRouterLLMParams> {
+    bind(modelId: string): BoundLLMModel<OpenRouterResponsesParams> {
       // Use the injected provider reference
       if (!providerRef) {
         throw new UPPError(
@@ -52,15 +52,15 @@ export function createResponsesLLMHandler(): LLMHandler<OpenRouterLLMParams> {
         );
       }
 
-      const model: BoundLLMModel<OpenRouterLLMParams> = {
+      const model: BoundLLMModel<OpenRouterResponsesParams> = {
         modelId,
         capabilities: OPENROUTER_CAPABILITIES,
 
-        get provider(): LLMProvider<OpenRouterLLMParams> {
+        get provider(): LLMProvider<OpenRouterResponsesParams> {
           return providerRef!;
         },
 
-        async complete(request: LLMRequest<OpenRouterLLMParams>): Promise<LLMResponse> {
+        async complete(request: LLMRequest<OpenRouterResponsesParams>): Promise<LLMResponse> {
           const apiKey = await resolveApiKey(
             request.config,
             'OPENROUTER_API_KEY',
@@ -102,7 +102,7 @@ export function createResponsesLLMHandler(): LLMHandler<OpenRouterLLMParams> {
           return transformResponse(data);
         },
 
-        stream(request: LLMRequest<OpenRouterLLMParams>): LLMStreamResult {
+        stream(request: LLMRequest<OpenRouterResponsesParams>): LLMStreamResult {
           const state = createStreamState();
           let responseResolve: (value: LLMResponse) => void;
           let responseReject: (error: Error) => void;