@llumiverse/drivers 1.1.0 → 1.2.0

package/src/openai/index.ts

@@ -1,6 +1,6 @@
 import {
-    AIModel,
     AbstractDriver,
+    AIModel,
     Completion,
     CompletionChunkObject,
     CompletionResult,
@@ -10,26 +10,26 @@ import {
     EmbeddingsResult,
     ExecutionOptions,
     ExecutionTokenUsage,
+    getConversationMeta,
+    getModelCapabilities,
+    incrementConversationTurn,
     JSONSchema,
     LlumiverseError,
     LlumiverseErrorContext,
+    modelModalitiesToArray,
     ModelType,
     OpenAiDalleOptions,
     OpenAiGptImageOptions,
     Providers,
+    stripBase64ImagesFromConversation,
+    stripHeartbeatsFromConversation,
+    supportsToolUse,
     ToolDefinition,
     ToolUse,
     TrainingJob,
     TrainingJobStatus,
     TrainingOptions,
     TrainingPromptOptions,
-    getConversationMeta,
-    getModelCapabilities,
-    incrementConversationTurn,
-    modelModalitiesToArray,
-    stripBase64ImagesFromConversation,
-    stripHeartbeatsFromConversation,
-    supportsToolUse,
     truncateLargeTextInConversation,
     unwrapConversationArray,
 } from "@llumiverse/core";
@@ -61,6 +61,29 @@ function textToCompletionResult(text: string): CompletionResult[] {
     return text ? [{ type: "text", value: text }] : [];
 }
 
+function isOpenAIReasoningModel(model: string): boolean {
+    const normalized = model.toLowerCase();
+    return normalized.includes("o1")
+        || normalized.includes("o3")
+        || normalized.includes("o4")
+        || normalized.includes("gpt-5");
+}
+
+function isGpt5ProModel(model: string): boolean {
+    const modelName = model.toLowerCase().split('/').pop() ?? model.toLowerCase();
+    return /^gpt-5(?:\.\d+)?-pro/.test(modelName);
+}
+
+function openAIReasoningEffort(model: string, effort: string | undefined): "low" | "medium" | "high" | undefined {
+    if (!effort || !isOpenAIReasoningModel(model)) {
+        return undefined;
+    }
+    if (isGpt5ProModel(model)) {
+        return "high";
+    }
+    return effort === "low" || effort === "medium" || effort === "high" ? effort : undefined;
+}
+
 //TODO: Do we need a list?, replace with if statements and modernize?
 const supportFineTunning = new Set([
     "gpt-3.5-turbo-1106",
@@ -109,8 +132,11 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
     }
 
     async requestTextCompletionStream(prompt: ResponseInputItem[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined &&
+            options.model_options?._option_id !== "openai-text" &&
+            options.model_options?._option_id !== "openai-thinking" &&
+            options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
 
         // Include conversation history (same as non-streaming)
@@ -144,8 +170,9 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             }
         }
 
-        const reasoning = model_options?.reasoning_effort ? { effort: model_options.reasoning_effort } : undefined;
-        const isReasoningModel = /\b(o1|o3|o4)\b/.test(options.model);
+        const isReasoningModel = isOpenAIReasoningModel(options.model);
+        const effort = openAIReasoningEffort(options.model, model_options?.effort ?? model_options?.reasoning_effort);
+        const reasoning = effort ? { effort } : undefined;
 
         const stream = await this.service.responses.create({
             stream: true,
@@ -170,8 +197,10 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
     }
 
     async requestTextCompletion(prompt: ResponseInputItem[], options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined &&
+            options.model_options?._option_id !== "openai-text" &&
+            options.model_options?._option_id !== "openai-thinking") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
 
         convertRoles(prompt, options.model);
@@ -204,8 +233,9 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             }
         }
 
-        const reasoning = model_options?.reasoning_effort ? { effort: model_options.reasoning_effort } : undefined;
-        const isReasoningModel = /\b(o1|o3|o4)\b/.test(options.model);
+        const isReasoningModel = isOpenAIReasoningModel(options.model);
+        const effort = openAIReasoningEffort(options.model, model_options?.effort ?? model_options?.reasoning_effort);
+        const reasoning = effort ? { effort } : undefined;
 
         const res = await this.service.responses.create({
             stream: false,

package/src/replicate.ts

@@ -1,6 +1,6 @@
 import {
-    AIModel,
     AbstractDriver,
+    AIModel,
     Completion,
     CompletionChunkObject,
     DataSource,
@@ -65,8 +65,8 @@ export class ReplicateDriver extends AbstractDriver<DriverOptions, string> {
     }
 
     async requestTextCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -110,8 +110,8 @@ export class ReplicateDriver extends AbstractDriver<DriverOptions, string> {
     }
 
     async requestTextCompletion(prompt: string, options: ExecutionOptions) {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions;
         const model = ReplicateDriver.parseModelId(options.model);

package/src/shared/claude-thinking.ts

@@ -0,0 +1,88 @@
+import type { OutputConfig, ThinkingConfigParam } from "@anthropic-ai/sdk/resources/messages.js";
+import {
+    hasSamplingParameterRestriction,
+    isClaudeVersionGTE,
+    supportsAdaptiveThinking,
+} from "@llumiverse/core";
+
+/**
+ * Common Claude model options relevant to thinking/effort configuration.
+ * Works with both VertexAIClaudeOptions and BedrockClaudeOptions.
+ */
+export interface ClaudeThinkingInput {
+    thinking_budget_tokens?: number;
+    effort?: NonNullable<OutputConfig['effort']>;
+    /** Controls whether thinking content is included in the response. Does not enable thinking. */
+    include_thoughts?: boolean;
+}
+
+/**
+ * Result of resolving Claude thinking and effort configuration.
+ */
+export interface ClaudeThinkingResult {
+    /** Thinking/reasoning config to include in the API payload. */
+    thinking: ThinkingConfigParam | undefined;
+    /** Output config (effort) to include in the API payload, if applicable. */
+    outputConfig: OutputConfig | undefined;
+    /** Whether sampling parameters (temperature, top_p, top_k) should be stripped. */
+    hasSamplingRestriction: boolean;
+    /** Whether the model supports thinking at all (>= Claude 3.7). */
+    supportsThinking: boolean;
+}
+
+/**
+ * Resolve thinking and effort configuration for a Claude model.
+ *
+ * - Extended thinking: enabled by setting `thinking_budget_tokens`.
+ * - Adaptive thinking: enabled by setting `effort` on models that support it (Opus 4.6+, Sonnet 4.6+).
+ * - `include_thoughts`: display-only; does not enable thinking.
+ *
+ * @param model - The model identifier string
+ * @param options - User-provided Claude options (thinking_budget_tokens, effort, include_thoughts)
+ */
+export function resolveClaudeThinking(model: string, options?: ClaudeThinkingInput): ClaudeThinkingResult {
+    const supportsAdaptive = supportsAdaptiveThinking(model);
+    const samplingRestriction = hasSamplingParameterRestriction(model);
+    const supportsThinking = isClaudeVersionGTE(model, 3, 7);
+    const budgetTokens = options?.thinking_budget_tokens;
+    // Adaptive thinking is active when the caller supplies an effort level on a
+    // model that supports it. Extended thinking is active when a budget is set.
+    const adaptiveEnabled = supportsAdaptive && options?.effort != null;
+    const extendedEnabled = budgetTokens != null;
+
+    let thinking: ThinkingConfigParam | undefined;
+
+    if (!supportsThinking) {
+        // Pre-3.7 models: no thinking support
+        thinking = undefined;
+    } else if (extendedEnabled) {
+        // Explicit budget — use extended thinking regardless of adaptive support.
+        // On adaptive models this uses the deprecated path, but user input takes priority.
+        thinking = {
+            type: "enabled" as const,
+            budget_tokens: budgetTokens,
+        };
+    } else if (supportsAdaptive) {
+        // Adaptive models: enable when effort is set, omit otherwise (thinking is OFF by default).
+        // display controls whether thinking blocks are returned; defaults to omitted.
+        thinking = adaptiveEnabled
+            ? { type: "adaptive" as const, display: options?.include_thoughts ? "summarized" : "omitted" }
+            : undefined;
+    } else {
+        // Older thinking models (3.7, 4.5): no adaptive support, thinking is always disabled
+        // unless an explicit budget is provided (handled above).
+        thinking = { type: "disabled" as const };
+    }
+
+    // Output config for effort parameter (Opus 4.5+, Sonnet 4.6+, all 4.7+)
+    const outputConfig: OutputConfig | undefined = options?.effort
+        ? { effort: options.effort }
+        : undefined;
+
+    return {
+        thinking,
+        outputConfig,
+        hasSamplingRestriction: samplingRestriction,
+        supportsThinking,
+    };
+}

package/src/togetherai/index.ts

@@ -1,4 +1,4 @@
-import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsResult, ExecutionOptions, TextFallbackOptions } from "@llumiverse/core";
+import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsResult, ExecutionOptions, TextFallbackOptions } from "@llumiverse/core";
 import { transformSSEStream } from "@llumiverse/core/async";
 import { FetchClient } from "@vertesia/api-fetch-client";
 import { TextCompletion, TogetherModelInfo } from "./interfaces.js";
@@ -30,8 +30,8 @@ export class TogetherAIDriver extends AbstractDriver<TogetherAIDriverOptions, st
     }
 
     async requestTextCompletion(prompt: string, options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -72,8 +72,8 @@ export class TogetherAIDriver extends AbstractDriver<TogetherAIDriverOptions, st
     }
 
     async requestTextCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 

package/src/vertexai/models/claude.ts

@@ -11,27 +11,28 @@ import {
     RateLimitError,
     UnprocessableEntityError,
 } from '@anthropic-ai/sdk/error';
-import { ContentBlock, ContentBlockParam, DocumentBlockParam, ImageBlockParam, Message, MessageParam, TextBlockParam, ToolResultBlockParam } from "@anthropic-ai/sdk/resources/index.js";
-import { MessageStreamParams } from "@anthropic-ai/sdk/resources/index.mjs";
-import { MessageCreateParamsBase, MessageCreateParamsNonStreaming, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages.js";
+import type { ContentBlock, ContentBlockParam, DocumentBlockParam, ImageBlockParam, Message, MessageParam, TextBlockParam, ToolResultBlockParam } from "@anthropic-ai/sdk/resources/index.js";
+import type { MessageStreamParams } from "@anthropic-ai/sdk/resources/index.mjs";
+import type { MessageCreateParamsBase, MessageCreateParamsNonStreaming, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages.js";
 import {
-    AIModel, Completion, CompletionChunkObject, ExecutionOptions, ExecutionTokenUsage,
+    type AIModel, type Completion, type CompletionChunkObject, type ExecutionOptions, type ExecutionTokenUsage,
     getConversationMeta,
     getMaxTokensLimitVertexAi,
     incrementConversationTurn,
-    JSONObject,
-    LlumiverseError, LlumiverseErrorContext,
+    type JSONObject,
+    LlumiverseError, type LlumiverseErrorContext,
     ModelType,
-    PromptRole, PromptSegment, readStreamAsBase64, readStreamAsString, StatelessExecutionOptions,
+    PromptRole, type PromptSegment, readStreamAsBase64, readStreamAsString, type StatelessExecutionOptions,
     stripBase64ImagesFromConversation,
     stripHeartbeatsFromConversation,
-    ToolUse,
+    type ToolUse,
     truncateLargeTextInConversation,
-    VertexAIClaudeOptions
+    type VertexAIClaudeOptions,
 } from "@llumiverse/core";
 import { asyncMap } from "@llumiverse/core/async";
-import { VertexAIDriver } from "../index.js";
-import { ModelDefinition } from "../models.js";
+import { resolveClaudeThinking } from "../../shared/claude-thinking.js";
+import type { VertexAIDriver } from "../index.js";
+import type { ModelDefinition } from "../models.js";
 
 export const ANTHROPIC_REGIONS: Record<string, string> = {
     us: "us-east5",
@@ -313,10 +314,13 @@ export class ClaudeModelDefinition implements ModelDefinition<ClaudePrompt> {
         options = { ...options, model: modelName };
 
         const client = await driver.getAnthropicClient(region);
-        options.model_options = options.model_options as VertexAIClaudeOptions;
+        const model_options = options.model_options as VertexAIClaudeOptions | undefined;
 
-        if (options.model_options?._option_id !== "vertexai-claude") {
-            driver.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (model_options?._option_id !== undefined &&
+            model_options?._option_id !== "vertexai-claude" &&
+            model_options?._option_id !== "text-fallback"
+        ) {
+            driver.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
 
         let conversation = updateConversation(options.conversation as ClaudePrompt, prompt);
@@ -328,7 +332,7 @@ export class ClaudeModelDefinition implements ModelDefinition<ClaudePrompt> {
         const result = await client.messages.create(nonStreamingPayload, requestOptions) satisfies Message;
 
         // Use the new function to collect text content, including thinking if enabled
-        const includeThoughts = options.model_options?.include_thoughts ?? false;
+        const includeThoughts = model_options?.include_thoughts ?? false;
         const text = collectAllTextContent(result.content, includeThoughts);
         const tool_use = collectTools(result.content);
 
@@ -371,8 +375,11 @@ export class ClaudeModelDefinition implements ModelDefinition<ClaudePrompt> {
         const client = await driver.getAnthropicClient(region);
         const model_options = options.model_options as VertexAIClaudeOptions | undefined;
 
-        if (model_options?._option_id !== "vertexai-claude") {
-            driver.logger.warn({ options: options.model_options }, "Invalid model options");
+        if ((model_options?._option_id !== undefined &&
+            model_options?._option_id !== "vertexai-claude" &&
+            model_options?._option_id !== "text-fallback")
+        ) {
+            driver.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
 
         // Include conversation history (same as non-streaming)
@@ -979,23 +986,21 @@ function getClaudePayload(options: ExecutionOptions, prompt: ClaudePrompt): { pa
         }
     }
 
+    // Resolve thinking, effort, and sampling restriction using shared Claude helper
+    const { thinking, outputConfig, hasSamplingRestriction } = resolveClaudeThinking(modelName, model_options);
+
     const payload = {
         messages: sanitizedMessages,
         system: sanitizedSystem,
         tools: sanitizedTools,
-        temperature: model_options?.temperature,
+        temperature: hasSamplingRestriction ? undefined : model_options?.temperature,
         model: modelName,
         max_tokens: maxToken(options),
-        top_p: model_options?.temperature != null ? undefined : model_options?.top_p,
-        top_k: model_options?.top_k,
+        top_p: hasSamplingRestriction ? undefined : (model_options?.temperature != null ? undefined : model_options?.top_p),
+        top_k: hasSamplingRestriction ? undefined : model_options?.top_k,
         stop_sequences: model_options?.stop_sequence,
-        thinking: model_options?.thinking_mode ?
-            {
-                budget_tokens: model_options?.thinking_budget_tokens ?? 1024,
-                type: "enabled" as const
-            } : {
-                type: "disabled" as const
-            }
+        thinking,
+        ...(outputConfig && { output_config: outputConfig }),
     };
 
     return { payload, requestOptions };

package/src/vertexai/models/gemini.ts

@@ -243,9 +243,12 @@ const recoverableToolCallReasons = [
 function geminiThinkingBudget(option: StatelessExecutionOptions) {
     const model_options = option.model_options as VertexAIGeminiOptions | undefined;
     // If thinking_budget_tokens is explicitly set in model options, use it directly
-    if (model_options?.thinking_budget_tokens) {
+    if (model_options?.thinking_budget_tokens !== undefined) {
         return model_options.thinking_budget_tokens;
     }
+    if (model_options?.effort) {
+        return geminiBudgetForEffort(option.model, model_options.effort);
+    }
     // Set minimum thinking level by default.
     // Docs: https://ai.google.dev/gemini-api/docs/thinking#set-budget
     if (getGeminiModelVersion(option.model) === '2.5') {
@@ -257,33 +260,76 @@ function geminiThinkingBudget(option: StatelessExecutionOptions) {
     return undefined;
 }
 
+function geminiThinkingLevelForEffort(model: string, effort: VertexAIGeminiOptions["effort"]): ThinkingLevel | undefined {
+    if (model.includes("gemini-3-pro-image")) {
+        return ThinkingLevel.HIGH;
+    }
+    if (model.includes("gemini-3.1-flash-image")) {
+        return effort === "low" ? ThinkingLevel.MINIMAL : ThinkingLevel.HIGH;
+    }
+    switch (effort) {
+        case "low":
+            return ThinkingLevel.LOW;
+        case "medium":
+            return ThinkingLevel.MEDIUM;
+        case "high":
+            return ThinkingLevel.HIGH;
+        default:
+            return undefined;
+    }
+}
+
+function geminiBudgetForEffort(model: string, effort: NonNullable<VertexAIGeminiOptions["effort"]>): number {
+    const isFlashLite = model.includes("flash-lite");
+    const isFlash = model.includes("flash") && !isFlashLite;
+    const isPro = model.includes("pro");
+
+    if (effort === "low") {
+        if (isPro) return 128;
+        if (isFlashLite) return 512;
+        if (isFlash) return 1;
+        return 1024;
+    }
+    if (effort === "medium") {
+        return 8192;
+    }
+    if (isPro) return 32768;
+    if (isFlash || isFlashLite) return 24576;
+    return 8192;
+}
+
 function geminiThinkingConfig(option: StatelessExecutionOptions): ThinkingConfig | undefined {
     const model_options = option.model_options as VertexAIGeminiOptions | undefined;
 
     // If thinking options are explicitly set in model options, use them directly
     const include_thoughts = model_options?.include_thoughts ?? false;
-    if (model_options?.thinking_budget_tokens || model_options?.thinking_level) {
+    if (model_options?.thinking_budget_tokens !== undefined || model_options?.thinking_level) {
         return {
             includeThoughts: include_thoughts,
             thinkingBudget: model_options.thinking_budget_tokens,
             thinkingLevel: model_options.thinking_level,
         };
     }
+    if (model_options?.effort) {
+        if (isGeminiModelVersionGte(option.model, '3.0')) {
+            return {
+                includeThoughts: include_thoughts,
+                thinkingLevel: geminiThinkingLevelForEffort(option.model, model_options.effort),
+            };
+        }
+        return {
+            includeThoughts: include_thoughts,
+            thinkingBudget: geminiBudgetForEffort(option.model, model_options.effort),
+        };
+    }
 
     // Set a low thinking level by default.
     // Docs: https://ai.google.dev/gemini-api/docs/thinking#set-budget
     // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/thinking
     if (isGeminiModelVersionGte(option.model, '3.0')) {
-        if (option.model.includes("gemini-3-pro-image")) {
-            // Does not support thinking level.
-            return {
-                includeThoughts: include_thoughts,
-                thinkingBudget: -1
-            };
-        }
         return {
             includeThoughts: include_thoughts,
-            thinkingLevel: ThinkingLevel.LOW
+            thinkingLevel: option.model.includes("gemini-3-pro-image") ? ThinkingLevel.HIGH : ThinkingLevel.LOW
         };
     }
     if (isGeminiModelVersionGte(option.model, '2.5')) {
@@ -914,4 +960,4 @@ function formatFunctionResponse(response: string): JSONObject {
     } else {
         return { output: response };
     }
-}
+}

package/src/vertexai/models/imagen.ts

@@ -323,8 +323,8 @@ export class ImagenModelDefinition {
     }
 
     async requestImageGeneration(driver: VertexAIDriver, prompt: ImagenPrompt, options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== "vertexai-imagen") {
-            driver.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "vertexai-imagen") {
+            driver.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as ImagenOptions | undefined;
 

package/src/watsonx/index.ts

@@ -1,4 +1,4 @@
-import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, TextFallbackOptions } from "@llumiverse/core";
+import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, TextFallbackOptions } from "@llumiverse/core";
 import { transformSSEStream } from "@llumiverse/core/async";
 import { FetchClient } from "@vertesia/api-fetch-client";
 import { GenerateEmbeddingPayload, GenerateEmbeddingResponse, WatsonAuthToken, WatsonxListModelResponse, WatsonxModelSpec, WatsonxTextGenerationPayload, WatsonxTextGenerationResponse } from "./interfaces.js";
@@ -30,8 +30,8 @@ export class WatsonxDriver extends AbstractDriver<WatsonxDriverOptions, string>
     }
 
     async requestTextCompletion(prompt: string, options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions | undefined;
 
@@ -65,8 +65,8 @@ export class WatsonxDriver extends AbstractDriver<WatsonxDriverOptions, string>
     }
 
     async requestTextCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn({ options: options.model_options }, "Invalid model options");
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
+            this.logger.debug({ options: options.model_options }, "Unexpected option id");
         }
         options.model_options = options.model_options as TextFallbackOptions | undefined;
         const payload: WatsonxTextGenerationPayload = {