@providerprotocol/ai 0.0.5 → 0.0.7

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;

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

@@ -11,7 +11,7 @@ import {
   isToolResultMessage,
 } from '../../types/messages.ts';
 import type {
-  OpenRouterLLMParams,
+  OpenRouterCompletionsParams,
   OpenRouterCompletionsRequest,
   OpenRouterCompletionsMessage,
   OpenRouterUserContent,
@@ -23,94 +23,30 @@ import type {
 
 /**
  * Transform UPP request to OpenRouter Chat Completions format
+ *
+ * Params are spread directly to allow pass-through of any OpenRouter 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 OpenRouterLLMParams>(
-  request: LLMRequest<TParams>,
+export function transformRequest(
+  request: LLMRequest<OpenRouterCompletionsParams>,
   modelId: string
 ): OpenRouterCompletionsRequest {
-  const params: OpenRouterLLMParams = request.params ?? {};
+  const params = request.params ?? ({} as OpenRouterCompletionsParams);
 
+  // Spread params to pass through all fields, then set required fields
   const openrouterRequest: OpenRouterCompletionsRequest = {
+    ...params,
     model: modelId,
     messages: transformMessages(request.messages, request.system),
   };
 
-  // Model parameters
-  if (params.temperature !== undefined) {
-    openrouterRequest.temperature = params.temperature;
-  }
-  if (params.top_p !== undefined) {
-    openrouterRequest.top_p = params.top_p;
-  }
-  if (params.top_k !== undefined) {
-    openrouterRequest.top_k = params.top_k;
-  }
-  if (params.min_p !== undefined) {
-    openrouterRequest.min_p = params.min_p;
-  }
-  if (params.top_a !== undefined) {
-    openrouterRequest.top_a = params.top_a;
-  }
-  if (params.max_tokens !== undefined) {
-    openrouterRequest.max_tokens = params.max_tokens;
-  }
-  if (params.frequency_penalty !== undefined) {
-    openrouterRequest.frequency_penalty = params.frequency_penalty;
-  }
-  if (params.presence_penalty !== undefined) {
-    openrouterRequest.presence_penalty = params.presence_penalty;
-  }
-  if (params.repetition_penalty !== undefined) {
-    openrouterRequest.repetition_penalty = params.repetition_penalty;
-  }
-  if (params.stop !== undefined) {
-    openrouterRequest.stop = params.stop;
-  }
-  if (params.logprobs !== undefined) {
-    openrouterRequest.logprobs = params.logprobs;
-  }
-  if (params.top_logprobs !== undefined) {
-    openrouterRequest.top_logprobs = params.top_logprobs;
-  }
-  if (params.seed !== undefined) {
-    openrouterRequest.seed = params.seed;
-  }
-  if (params.user !== undefined) {
-    openrouterRequest.user = params.user;
-  }
-  if (params.logit_bias !== undefined) {
-    openrouterRequest.logit_bias = params.logit_bias;
-  }
-  if (params.prediction !== undefined) {
-    openrouterRequest.prediction = params.prediction;
-  }
-
-  // OpenRouter-specific parameters
-  if (params.transforms !== undefined) {
-    openrouterRequest.transforms = params.transforms;
-  }
-  if (params.models !== undefined) {
-    openrouterRequest.models = params.models;
-  }
-  if (params.route !== undefined) {
-    openrouterRequest.route = params.route;
-  }
-  if (params.provider !== undefined) {
-    openrouterRequest.provider = params.provider;
-  }
-  if (params.debug !== undefined) {
-    openrouterRequest.debug = params.debug;
-  }
-
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     openrouterRequest.tools = request.tools.map(transformTool);
-    if (params.parallel_tool_calls !== undefined) {
-      openrouterRequest.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 OpenRouterLLMParams>(
         strict: true,
       },
     };
-  } else if (params.response_format !== undefined) {
-    // Pass through response_format from params if no structure is defined
-    openrouterRequest.response_format = params.response_format;
   }
 
   return openrouterRequest;

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

@@ -11,7 +11,7 @@ import {
   isToolResultMessage,
 } from '../../types/messages.ts';
 import type {
-  OpenRouterLLMParams,
+  OpenRouterResponsesParams,
   OpenRouterResponsesRequest,
   OpenRouterResponsesInputItem,
   OpenRouterResponsesContentPart,
@@ -25,43 +25,30 @@ import type {
 
 /**
  * Transform UPP request to OpenRouter Responses API format
+ *
+ * Params are spread directly to allow pass-through of any OpenRouter 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 OpenRouterLLMParams>(
-  request: LLMRequest<TParams>,
+export function transformRequest(
+  request: LLMRequest<OpenRouterResponsesParams>,
   modelId: string
 ): OpenRouterResponsesRequest {
-  const params: OpenRouterLLMParams = request.params ?? {};
+  const params = request.params ?? ({} as OpenRouterResponsesParams);
 
+  // Spread params to pass through all fields, then set required fields
   const openrouterRequest: OpenRouterResponsesRequest = {
+    ...params,
     model: modelId,
     input: transformInputItems(request.messages, request.system),
   };
 
-  // Model parameters
-  if (params.temperature !== undefined) {
-    openrouterRequest.temperature = params.temperature;
-  }
-  if (params.top_p !== undefined) {
-    openrouterRequest.top_p = params.top_p;
-  }
-  if (params.max_output_tokens !== undefined) {
-    openrouterRequest.max_output_tokens = params.max_output_tokens;
-  } else if (params.max_tokens !== undefined) {
-    openrouterRequest.max_output_tokens = params.max_tokens;
-  }
-  if (params.reasoning !== undefined) {
-    openrouterRequest.reasoning = { ...params.reasoning };
-  }
-
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     openrouterRequest.tools = request.tools.map(transformTool);
-    if (params.parallel_tool_calls !== undefined) {
-      openrouterRequest.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/openrouter/types.ts

@@ -1,18 +1,11 @@
 /**
- * OpenRouter-specific LLM parameters
- * These are passed through to the OpenRouter APIs
+ * OpenRouter Chat Completions API parameters
+ * These are passed through to the /api/v1/chat/completions endpoint
  */
-export interface OpenRouterLLMParams {
-  // ============================================
-  // Common Parameters (both APIs)
-  // ============================================
-
+export interface OpenRouterCompletionsParams {
   /** 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;
 
@@ -55,24 +48,12 @@ export interface OpenRouterLLMParams {
   /** Top-a sampling threshold (0.0 - 1.0) */
   top_a?: number;
 
-  // ============================================
-  // Tool Calling
-  // ============================================
-
   /** Whether to enable parallel tool calls */
   parallel_tool_calls?: boolean;
 
-  // ============================================
-  // Structured Output
-  // ============================================
-
-  /** Response format for structured output (Chat Completions API only) */
+  /** Response format for structured output */
   response_format?: OpenRouterResponseFormat;
 
-  // ============================================
-  // OpenRouter-Specific Parameters
-  // ============================================
-
   /**
    * Prompt transforms to apply
    * See: https://openrouter.ai/docs/guides/features/message-transforms
@@ -98,7 +79,6 @@ export interface OpenRouterLLMParams {
 
   /**
    * Predicted output for latency optimization
-   * https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs
    */
   prediction?: {
     type: 'content';
@@ -112,13 +92,27 @@ export interface OpenRouterLLMParams {
     /** If true, returns the transformed request body sent to the provider */
     echo_upstream_body?: boolean;
   };
+}
 
-  // ============================================
-  // Responses API Specific
-  // ============================================
+/**
+ * OpenRouter Responses API parameters (Beta)
+ * These are passed through to the /api/v1/responses endpoint
+ */
+export interface OpenRouterResponsesParams {
+  /** 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 (Responses API)
+   * Reasoning configuration
    */
   reasoning?: {
     effort?: 'low' | 'medium' | 'high';

package/src/providers/xai/index.ts

@@ -7,7 +7,10 @@ import type {
 import { createCompletionsLLMHandler } from './llm.completions.ts';
 import { createResponsesLLMHandler } from './llm.responses.ts';
 import { createMessagesLLMHandler } from './llm.messages.ts';
-import type { XAILLMParams, XAIConfig, XAIAPIMode } from './types.ts';
+import type { XAICompletionsParams, XAIResponsesParams, XAIMessagesParams, XAIConfig, XAIAPIMode } from './types.ts';
+
+/** Union type for modalities interface */
+type XAILLMParamsUnion = XAICompletionsParams | XAIResponsesParams | XAIMessagesParams;
 
 /**
  * xAI provider options
@@ -58,7 +61,7 @@ export interface XAIProvider extends Provider<XAIProviderOptions> {
 
   /** Supported modalities */
   readonly modalities: {
-    llm: LLMHandler<XAILLMParams>;
+    llm: LLMHandler<XAILLMParamsUnion>;
   };
 }
 
@@ -86,15 +89,15 @@ function createXAIProvider(): XAIProvider {
 
   // Create a dynamic modalities object that returns the correct handler
   const modalities = {
-    get llm(): LLMHandler<XAILLMParams> {
+    get llm(): LLMHandler<XAILLMParamsUnion> {
       switch (currentApiMode) {
         case 'responses':
-          return responsesHandler;
+          return responsesHandler as unknown as LLMHandler<XAILLMParamsUnion>;
         case 'messages':
-          return messagesHandler;
+          return messagesHandler as unknown as LLMHandler<XAILLMParamsUnion>;
         case 'completions':
         default:
-          return completionsHandler;
+          return completionsHandler as unknown as LLMHandler<XAILLMParamsUnion>;
       }
     },
   };
@@ -121,9 +124,9 @@ function createXAIProvider(): XAIProvider {
   const provider = fn as XAIProvider;
 
   // Inject provider reference into all handlers (spec compliance)
-  completionsHandler._setProvider?.(provider as unknown as LLMProvider<XAILLMParams>);
-  responsesHandler._setProvider?.(provider as unknown as LLMProvider<XAILLMParams>);
-  messagesHandler._setProvider?.(provider as unknown as LLMProvider<XAILLMParams>);
+  completionsHandler._setProvider?.(provider as unknown as LLMProvider<XAICompletionsParams>);
+  responsesHandler._setProvider?.(provider as unknown as LLMProvider<XAIResponsesParams>);
+  messagesHandler._setProvider?.(provider as unknown as LLMProvider<XAIMessagesParams>);
 
   return provider;
 }
@@ -208,7 +211,9 @@ export const xai = createXAIProvider();
 
 // Re-export types
 export type {
-  XAILLMParams,
+  XAICompletionsParams,
+  XAIResponsesParams,
+  XAIMessagesParams,
   XAIConfig,
   XAIAPIMode,
   XAIModelOptions,