@providerprotocol/ai 0.0.5 → 0.0.6

package/src/providers/anthropic/transform.ts

@@ -25,6 +25,10 @@ import type {
 
 /**
  * Transform UPP request to Anthropic format
+ *
+ * Params are spread directly to allow pass-through of any Anthropic 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 AnthropicLLMParams>(
   request: LLMRequest<TParams>,
@@ -32,45 +36,19 @@ export function transformRequest<TParams extends AnthropicLLMParams>(
 ): AnthropicRequest {
   const params = (request.params ?? {}) as AnthropicLLMParams;
 
+  // Spread params to pass through all fields, then set required fields
   const anthropicRequest: AnthropicRequest = {
+    ...params,
     model: modelId,
     messages: request.messages.map(transformMessage),
   };
 
-  // Only include max_tokens if provided - let Anthropic API enforce its requirement
-  if (params.max_tokens !== undefined) {
-    anthropicRequest.max_tokens = params.max_tokens;
-  }
-
   // System prompt (top-level in Anthropic)
   if (request.system) {
     anthropicRequest.system = request.system;
   }
 
-  // Model parameters
-  if (params.temperature !== undefined) {
-    anthropicRequest.temperature = params.temperature;
-  }
-  if (params.top_p !== undefined) {
-    anthropicRequest.top_p = params.top_p;
-  }
-  if (params.top_k !== undefined) {
-    anthropicRequest.top_k = params.top_k;
-  }
-  if (params.stop_sequences) {
-    anthropicRequest.stop_sequences = params.stop_sequences;
-  }
-  if (params.metadata) {
-    anthropicRequest.metadata = params.metadata;
-  }
-  if (params.thinking) {
-    anthropicRequest.thinking = params.thinking;
-  }
-  if (params.service_tier !== undefined) {
-    anthropicRequest.service_tier = params.service_tier;
-  }
-
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     anthropicRequest.tools = request.tools.map(transformTool);
     anthropicRequest.tool_choice = { type: 'auto' };

package/src/providers/google/transform.ts

@@ -23,6 +23,10 @@ import type {
 
 /**
  * Transform UPP request to Google format
+ *
+ * Params are spread into generationConfig to allow pass-through of any Google 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 GoogleLLMParams>(
   request: LLMRequest<TParams>,
@@ -41,54 +45,10 @@ export function transformRequest<TParams extends GoogleLLMParams>(
     };
   }
 
-  // Generation config
-  const generationConfig: NonNullable<GoogleRequest['generationConfig']> = {};
-
-  if (params.maxOutputTokens !== undefined) {
-    generationConfig.maxOutputTokens = params.maxOutputTokens;
-  }
-  if (params.temperature !== undefined) {
-    generationConfig.temperature = params.temperature;
-  }
-  if (params.topP !== undefined) {
-    generationConfig.topP = params.topP;
-  }
-  if (params.topK !== undefined) {
-    generationConfig.topK = params.topK;
-  }
-  if (params.stopSequences !== undefined) {
-    generationConfig.stopSequences = params.stopSequences;
-  }
-  if (params.candidateCount !== undefined) {
-    generationConfig.candidateCount = params.candidateCount;
-  }
-  if (params.responseMimeType !== undefined) {
-    generationConfig.responseMimeType = params.responseMimeType;
-  }
-  if (params.responseSchema !== undefined) {
-    generationConfig.responseSchema = params.responseSchema as Record<string, unknown>;
-  }
-  if (params.presencePenalty !== undefined) {
-    generationConfig.presencePenalty = params.presencePenalty;
-  }
-  if (params.frequencyPenalty !== undefined) {
-    generationConfig.frequencyPenalty = params.frequencyPenalty;
-  }
-  if (params.seed !== undefined) {
-    generationConfig.seed = params.seed;
-  }
-  if (params.responseLogprobs !== undefined) {
-    generationConfig.responseLogprobs = params.responseLogprobs;
-  }
-  if (params.logprobs !== undefined) {
-    generationConfig.logprobs = params.logprobs;
-  }
-  if (params.audioTimestamp !== undefined) {
-    generationConfig.audioTimestamp = params.audioTimestamp;
-  }
-  if (params.thinkingConfig !== undefined) {
-    generationConfig.thinkingConfig = params.thinkingConfig;
-  }
+  // Spread params into generationConfig to pass through all fields
+  const generationConfig: NonNullable<GoogleRequest['generationConfig']> = {
+    ...params,
+  };
 
   // Protocol-level structured output (overrides provider-specific settings)
   if (request.structure) {
@@ -100,7 +60,7 @@ export function transformRequest<TParams extends GoogleLLMParams>(
     googleRequest.generationConfig = generationConfig;
   }
 
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     googleRequest.tools = [
       {

package/src/providers/ollama/transform.ts

@@ -23,6 +23,14 @@ import type {
 
 /**
  * Transform UPP request to Ollama format
+ *
+ * Params are spread to allow pass-through of any Ollama API fields,
+ * even those not explicitly defined in our type. This enables developers to
+ * use new API features without waiting for library updates.
+ *
+ * Note: Ollama uses nested 'options' for model parameters. Params that belong
+ * in options (like temperature, top_p, etc.) are spread into options, while
+ * top-level params (like keep_alive, think) are spread at the request level.
  */
 export function transformRequest<TParams extends OllamaLLMParams>(
   request: LLMRequest<TParams>,
@@ -30,63 +38,33 @@ export function transformRequest<TParams extends OllamaLLMParams>(
 ): OllamaRequest {
   const params = (request.params ?? {}) as OllamaLLMParams;
 
+  // Extract top-level params vs options params
+  const {
+    keep_alive,
+    think,
+    logprobs,
+    top_logprobs,
+    ...optionsParams
+  } = params;
+
+  // Spread params to pass through all fields, then set required fields
   const ollamaRequest: OllamaRequest = {
     model: modelId,
     messages: transformMessages(request.messages, request.system),
   };
 
-  // Build options object for runtime parameters
-  const options: OllamaOptions = {};
-
-  if (params.num_predict !== undefined) options.num_predict = params.num_predict;
-  if (params.temperature !== undefined) options.temperature = params.temperature;
-  if (params.top_p !== undefined) options.top_p = params.top_p;
-  if (params.top_k !== undefined) options.top_k = params.top_k;
-  if (params.min_p !== undefined) options.min_p = params.min_p;
-  if (params.typical_p !== undefined) options.typical_p = params.typical_p;
-  if (params.repeat_penalty !== undefined) options.repeat_penalty = params.repeat_penalty;
-  if (params.repeat_last_n !== undefined) options.repeat_last_n = params.repeat_last_n;
-  if (params.presence_penalty !== undefined) options.presence_penalty = params.presence_penalty;
-  if (params.frequency_penalty !== undefined) options.frequency_penalty = params.frequency_penalty;
-  if (params.mirostat !== undefined) options.mirostat = params.mirostat;
-  if (params.mirostat_eta !== undefined) options.mirostat_eta = params.mirostat_eta;
-  if (params.mirostat_tau !== undefined) options.mirostat_tau = params.mirostat_tau;
-  if (params.penalize_newline !== undefined) options.penalize_newline = params.penalize_newline;
-  if (params.stop !== undefined) options.stop = params.stop;
-  if (params.seed !== undefined) options.seed = params.seed;
-  if (params.num_keep !== undefined) options.num_keep = params.num_keep;
-  if (params.num_ctx !== undefined) options.num_ctx = params.num_ctx;
-  if (params.num_batch !== undefined) options.num_batch = params.num_batch;
-  if (params.num_thread !== undefined) options.num_thread = params.num_thread;
-  if (params.num_gpu !== undefined) options.num_gpu = params.num_gpu;
-  if (params.main_gpu !== undefined) options.main_gpu = params.main_gpu;
-  if (params.low_vram !== undefined) options.low_vram = params.low_vram;
-  if (params.f16_kv !== undefined) options.f16_kv = params.f16_kv;
-  if (params.use_mmap !== undefined) options.use_mmap = params.use_mmap;
-  if (params.use_mlock !== undefined) options.use_mlock = params.use_mlock;
-  if (params.vocab_only !== undefined) options.vocab_only = params.vocab_only;
-  if (params.numa !== undefined) options.numa = params.numa;
-  if (params.tfs_z !== undefined) options.tfs_z = params.tfs_z;
-
-  if (Object.keys(options).length > 0) {
-    ollamaRequest.options = options;
-  }
+  // Add top-level params if provided
+  if (keep_alive !== undefined) ollamaRequest.keep_alive = keep_alive;
+  if (think !== undefined) ollamaRequest.think = think;
+  if (logprobs !== undefined) ollamaRequest.logprobs = logprobs;
+  if (top_logprobs !== undefined) ollamaRequest.top_logprobs = top_logprobs;
 
-  // Top-level parameters
-  if (params.keep_alive !== undefined) {
-    ollamaRequest.keep_alive = params.keep_alive;
-  }
-  if (params.think !== undefined) {
-    ollamaRequest.think = params.think;
-  }
-  if (params.logprobs !== undefined) {
-    ollamaRequest.logprobs = params.logprobs;
-  }
-  if (params.top_logprobs !== undefined) {
-    ollamaRequest.top_logprobs = params.top_logprobs;
+  // Spread remaining params into options to pass through all model parameters
+  if (Object.keys(optionsParams).length > 0) {
+    ollamaRequest.options = optionsParams as OllamaOptions;
   }
 
-  // Tools
+  // Tools come from request, not params
   if (request.tools && request.tools.length > 0) {
     ollamaRequest.tools = request.tools.map(transformTool);
   }

package/src/providers/openai/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 { OpenAILLMParams, OpenAIConfig } from './types.ts';
+import type { OpenAICompletionsParams, OpenAIResponsesParams, OpenAIConfig } from './types.ts';
+
+/** Union type for modalities interface */
+type OpenAILLMParamsUnion = OpenAICompletionsParams | OpenAIResponsesParams;
 
 /**
  * OpenAI provider options
@@ -51,7 +54,7 @@ export interface OpenAIProvider extends Provider<OpenAIProviderOptions> {
 
   /** Supported modalities */
   readonly modalities: {
-    llm: LLMHandler<OpenAILLMParams>;
+    llm: LLMHandler<OpenAILLMParamsUnion>;
   };
 }
 
@@ -77,10 +80,10 @@ function createOpenAIProvider(): OpenAIProvider {
 
   // Create a dynamic modalities object that returns the correct handler
   const modalities = {
-    get llm(): LLMHandler<OpenAILLMParams> {
+    get llm(): LLMHandler<OpenAILLMParamsUnion> {
       return currentApiMode === 'completions'
-        ? completionsHandler
-        : responsesHandler;
+        ? (completionsHandler as unknown as LLMHandler<OpenAILLMParamsUnion>)
+        : (responsesHandler as unknown as LLMHandler<OpenAILLMParamsUnion>);
     },
   };
 
@@ -106,8 +109,8 @@ function createOpenAIProvider(): OpenAIProvider {
   const provider = fn as OpenAIProvider;
 
   // Inject provider reference into both handlers (spec compliance)
-  responsesHandler._setProvider?.(provider as unknown as LLMProvider<OpenAILLMParams>);
-  completionsHandler._setProvider?.(provider as unknown as LLMProvider<OpenAILLMParams>);
+  responsesHandler._setProvider?.(provider as unknown as LLMProvider<OpenAIResponsesParams>);
+  completionsHandler._setProvider?.(provider as unknown as LLMProvider<OpenAICompletionsParams>);
 
   return provider;
 }
@@ -143,7 +146,8 @@ export const openai = createOpenAIProvider();
 
 // Re-export types
 export type {
-  OpenAILLMParams,
+  OpenAICompletionsParams,
+  OpenAIResponsesParams,
   OpenAIConfig,
   OpenAIAPIMode,
   OpenAIModelOptions,

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',