@llumiverse/drivers 0.22.0 → 0.23.0-dev-20251118

package/src/groq/index.ts

@@ -1,9 +1,10 @@
-import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
+import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions, ToolDefinition, ToolUse } from "@llumiverse/core";
 import { transformAsyncIterator } from "@llumiverse/core/async";
 import { formatOpenAILikeMultimodalPrompt } from "../openai/openai_format.js";
 
 import Groq from "groq-sdk";
-import type { ChatCompletionMessageParam } from "groq-sdk/resources/chat/completions";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "groq-sdk/resources/chat/completions";
+import type { FunctionParameters } from "groq-sdk/resources/shared";
 
 interface GroqDriverOptions extends DriverOptions {
     apiKey: string;
@@ -52,7 +53,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
             ...opts,
             multimodal: true,
         });
-        
+
         // Convert OpenAI ChatCompletionMessageParam[] to Groq ChatCompletionMessageParam[]
         // Handle differences between OpenAI and Groq SDK types
         const groqMessages: ChatCompletionMessageParam[] = openaiMessages.map(msg => {
@@ -60,7 +61,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
             if (msg.role === 'developer' || msg.role === 'system') {
                 const systemMsg: ChatCompletionMessageParam = {
                     role: 'system',
-                    content: Array.isArray(msg.content) 
+                    content: Array.isArray(msg.content)
                         ? msg.content.map(part => part.text).join('\n')
                         : msg.content,
                     // Preserve name if present
@@ -68,23 +69,23 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
                 };
                 return systemMsg;
             }
-            
+
             // Handle user messages - filter content parts to only supported types
             if (msg.role === 'user') {
-                let content: string | Array<{type: 'text', text: string} | {type: 'image_url', image_url: {url: string, detail?: 'auto' | 'low' | 'high'}}> | undefined = undefined;
-                
+                let content: string | Array<{ type: 'text', text: string } | { type: 'image_url', image_url: { url: string, detail?: 'auto' | 'low' | 'high' } }> | undefined = undefined;
+
                 if (typeof msg.content === 'string') {
                     content = msg.content;
                 } else if (Array.isArray(msg.content)) {
                     // Filter to only text and image_url parts that Groq supports
-                    const supportedParts = msg.content.filter(part => 
+                    const supportedParts = msg.content.filter(part =>
                         part.type === 'text' || part.type === 'image_url'
                     ).map(part => {
                         if (part.type === 'text') {
                             return { type: 'text' as const, text: part.text };
                         } else if (part.type === 'image_url') {
-                            return { 
-                                type: 'image_url' as const, 
+                            return {
+                                type: 'image_url' as const,
                                 image_url: {
                                     url: part.image_url.url,
                                     ...(part.image_url.detail && { detail: part.image_url.detail })
@@ -92,11 +93,11 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
                             };
                         }
                         return null;
-                    }).filter(Boolean) as Array<{type: 'text', text: string} | {type: 'image_url', image_url: {url: string, detail?: 'auto' | 'low' | 'high'}}>;
-                    
+                    }).filter(Boolean) as Array<{ type: 'text', text: string } | { type: 'image_url', image_url: { url: string, detail?: 'auto' | 'low' | 'high' } }>;
+
                     content = supportedParts.length > 0 ? supportedParts : 'Content not supported';
                 }
-                
+
                 const userMsg: ChatCompletionMessageParam = {
                     role: 'user',
                     content: content ?? "",
@@ -105,34 +106,33 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
                 };
                 return userMsg;
             }
-            
+
             // Handle assistant messages - handle content arrays if needed
             if (msg.role === 'assistant') {
                 const assistantMsg: ChatCompletionMessageParam = {
                     role: 'assistant',
-                    content: Array.isArray(msg.content) 
+                    content: Array.isArray(msg.content)
                         ? msg.content.map(part => 'text' in part ? part.text : '').filter(Boolean).join('\n') || null
                         : msg.content,
                     // Preserve other assistant message properties
-                    ...(msg.function_call && { function_call: msg.function_call }),
                     ...(msg.tool_calls && { tool_calls: msg.tool_calls }),
                     ...(msg.name && { name: msg.name })
                 };
                 return assistantMsg;
             }
-            
+
             // For tool and function messages, they should be compatible
             if (msg.role === 'tool') {
                 const toolMsg: ChatCompletionMessageParam = {
                     role: 'tool',
                     tool_call_id: msg.tool_call_id,
-                    content: Array.isArray(msg.content) 
+                    content: Array.isArray(msg.content)
                         ? msg.content.map(part => part.text).join('\n')
                         : msg.content
                 };
                 return toolMsg;
             }
-            
+
             if (msg.role === 'function') {
                 const functionMsg: ChatCompletionMessageParam = {
                     role: 'function',
@@ -141,7 +141,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
                 };
                 return functionMsg;
             }
-            
+
             // Fallback - should not reach here but provides type safety
             throw new Error(`Unsupported message role: ${(msg as any).role}`);
         });
@@ -149,15 +149,67 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         return groqMessages;
     }
 
+    private getToolDefinitions(tools: ToolDefinition[] | undefined): ChatCompletionTool[] | undefined {
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+
+        return tools.map(tool => ({
+            type: 'function' as const,
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema satisfies FunctionParameters,
+            }
+        }));
+    }
+
+    private extractToolUse(message: any): ToolUse[] | undefined {
+        if (!message.tool_calls || message.tool_calls.length === 0) {
+            return undefined;
+        }
+
+        return message.tool_calls.map((toolCall: any) => ({
+            id: toolCall.id,
+            tool_name: toolCall.function.name,
+            tool_input: JSON.parse(toolCall.function.arguments || '{}'),
+        }));
+    }
+
+    private sanitizeMessagesForGroq(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
+        return messages.map(message => {
+            // Remove any reasoning field from message objects
+            const { reasoning, ...sanitizedMessage } = message as any;
+
+            // If message has content array, filter out reasoning content types
+            if (Array.isArray(sanitizedMessage.content)) {
+                sanitizedMessage.content = sanitizedMessage.content.filter((part: any) => {
+                    // Filter out any reasoning-related content parts
+                    return part.type !== 'reasoning' && !('reasoning' in part);
+                });
+            }
+
+            return sanitizedMessage as ChatCompletionMessageParam;
+        });
+    }
+
     async requestTextCompletion(messages: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<Completion> {
         if (options.model_options?._option_id !== "text-fallback" && options.model_options?._option_id !== "groq-deepseek-thinking") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
+        // Update conversation with current messages
+        let conversation = updateConversation(options.conversation as ChatCompletionMessageParam[], messages);
+
+        // Filter out any reasoning content that Groq doesn't support
+        conversation = this.sanitizeMessagesForGroq(conversation);
+
+        const tools = this.getToolDefinitions(options.tools);
+
         const res = await this.client.chat.completions.create({
             model: options.model,
-            messages: messages,
+            messages: conversation,
             max_completion_tokens: options.model_options?.max_tokens,
             temperature: options.model_options?.temperature,
             top_p: options.model_options?.top_p,
@@ -166,33 +218,54 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
             presence_penalty: options.model_options?.presence_penalty,
             frequency_penalty: options.model_options?.frequency_penalty,
             response_format: this.getResponseFormat(options),
+            tools: tools,
         });
 
-
         const choice = res.choices[0];
         const result = choice.message.content;
 
+        // Extract tool use from the response
+        const tool_use = this.extractToolUse(choice.message);
+
+        // Update conversation with the response
+        conversation = updateConversation(conversation, [choice.message]);
+
+        let finish_reason = choice.finish_reason;
+        if (tool_use && tool_use.length > 0) {
+            finish_reason = "tool_calls";
+        }
+
         return {
-            result: result,
+            result: result ? [{ type: "text", value: result }] : [],
             token_usage: {
                 prompt: res.usage?.prompt_tokens,
                 result: res.usage?.completion_tokens,
                 total: res.usage?.total_tokens,
             },
-            finish_reason: choice.finish_reason,
+            finish_reason: finish_reason,
             original_response: options.include_original_response ? res : undefined,
+            conversation,
+            tool_use,
         };
     }
 
-    async requestTextCompletionStream(messages: ChatCompletionMessageParam[], options: ExecutionOptions): Promise <AsyncIterable<CompletionChunkObject>> {
+    async requestTextCompletionStream(messages: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
         if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
+        // Update conversation with current messages
+        let conversation = updateConversation(options.conversation as ChatCompletionMessageParam[], messages);
+
+        // Filter out any reasoning content that Groq doesn't support
+        conversation = this.sanitizeMessagesForGroq(conversation);
+
+        const tools = this.getToolDefinitions(options.tools);
+
         const res = await this.client.chat.completions.create({
             model: options.model,
-            messages: messages,
+            messages: conversation,
             max_completion_tokens: options.model_options?.max_tokens,
             temperature: options.model_options?.temperature,
             top_p: options.model_options?.top_p,
@@ -201,17 +274,28 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
             presence_penalty: options.model_options?.presence_penalty,
             frequency_penalty: options.model_options?.frequency_penalty,
             stream: true,
+            tools: tools,
         });
 
-        return transformAsyncIterator(res, (res) => ({
-            result: res.choices[0].delta.content ?? '',
-            finish_reason: res.choices[0].finish_reason,
-            token_usage: {
-                prompt: res.x_groq?.usage?.prompt_tokens,
-                result: res.x_groq?.usage?.completion_tokens,
-                total: res.x_groq?.usage?.total_tokens,
-            },
-            } as CompletionChunkObject));
+        return transformAsyncIterator(res, (chunk) => {
+            const choice = chunk.choices[0];
+            let finish_reason = choice.finish_reason;
+
+            // Check for tool calls in the delta
+            if (choice.delta.tool_calls && choice.delta.tool_calls.length > 0) {
+                finish_reason = "tool_calls";
+            }
+
+            return {
+                result: choice.delta.content ? [{ type: "text", value: choice.delta.content }] : [],
+                finish_reason: finish_reason ?? undefined,
+                token_usage: {
+                    prompt: chunk.x_groq?.usage?.prompt_tokens,
+                    result: chunk.x_groq?.usage?.completion_tokens,
+                    total: chunk.x_groq?.usage?.total_tokens,
+                },
+            } satisfies CompletionChunkObject;
+        });
     }
 
     async listModels(): Promise<AIModel<string>[]> {
@@ -245,4 +329,17 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         throw new Error("Method not implemented.");
     }
 
+}
+
+/**
+ * Update the conversation messages by combining existing conversation with new messages
+ * @param conversation Existing conversation messages
+ * @param messages New messages to add
+ * @returns Combined conversation
+ */
+function updateConversation(
+    conversation: ChatCompletionMessageParam[] | undefined,
+    messages: ChatCompletionMessageParam[]
+): ChatCompletionMessageParam[] {
+    return (conversation || []).concat(messages);
 }

package/src/huggingface_ie.ts

@@ -1,7 +1,6 @@
 import {
-    HfInference,
-    HfInferenceEndpoint,
-    TextGenerationStreamOutput
+    InferenceClient,
+    TextGenerationStreamOutput,
 } from "@huggingface/inference";
 import {
     AIModel,
@@ -25,7 +24,7 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
     static PROVIDER = "huggingface_ie";
     provider = HuggingFaceIEDriver.PROVIDER;
     service: FetchClient;
-    _executor?: HfInferenceEndpoint;
+    _executor?: InferenceClient;
 
     constructor(
         options: HuggingFaceIEDriverOptions
@@ -60,7 +59,8 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
                     `Endpoint ${model} is not running - current status: ${endpoint.status}`
                 );
 
-            this._executor = new HfInference(this.options.apiKey).endpoint(
+            // Use the new InferenceClient and bind it to the endpoint URL
+            this._executor = new InferenceClient(this.options.apiKey).endpoint(
                 endpoint.url
             );
         }
@@ -69,7 +69,7 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
 
     async requestTextCompletionStream(prompt: string, options: ExecutionOptions) {
         if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -81,31 +81,30 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
                 max_new_tokens: options.model_options?.max_tokens,
             },
         });
-        
 
-        return transformAsyncIterator(req, (val: TextGenerationStreamOutput) => {
+        return transformAsyncIterator(req, (val: TextGenerationStreamOutput): CompletionChunkObject => {
             //special like <s> are not part of the result
-            if (val.token.special) return { result: "" };
+            if (val.token.special) return { result: [] };
             let finish_reason = val.details?.finish_reason as string;
             if (finish_reason === "eos_token") {
                 finish_reason = "stop";
             }
             return {
-                result: val.token.text ?? '',
+                result: val.token.text ? [{ type: "text" as const, value: val.token.text }] : [],
                 finish_reason: finish_reason,
                 token_usage: {
                     result: val.details?.generated_tokens ?? 0,
                 }
-            } as CompletionChunkObject;
+            };
         });
     }
 
     async requestTextCompletion(prompt: string, options: ExecutionOptions) {
         if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
-    
+
         const executor = await this.getExecutor(options.model);
         const res = await executor.textGeneration({
             inputs: prompt,
@@ -120,7 +119,7 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
             finish_reason = "stop";
         }
         return {
-            result: res.generated_text,
+            result: [{ type: "text" as const, value: res.generated_text }],
             finish_reason: finish_reason,
             token_usage: {
                 result: res.details?.generated_tokens

package/src/index.ts

@@ -1,12 +1,12 @@
+export * from "./azure/azure_foundry.js";
 export * from "./bedrock/index.js";
 export * from "./groq/index.js";
 export * from "./huggingface_ie.js";
 export * from "./mistral/index.js";
 export * from "./openai/azure_openai.js";
-export * from "./azure/azure_foundry.js";
 export * from "./openai/openai.js";
 export * from "./replicate.js";
-export * from "./test/index.js";
+export * from "./test-driver/index.js";
 export * from "./togetherai/index.js";
 export * from "./vertexai/index.js";
 export * from "./watsonx/index.js";

package/src/mistral/index.ts

@@ -1,4 +1,4 @@
-import { AIModel, AbstractDriver, Completion, CompletionChunk, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
+import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
 import { transformSSEStream } from "@llumiverse/core/async";
 import { getJSONSafetyNotice } from "@llumiverse/core/formatters";
 import { formatOpenAILikeTextPrompt, OpenAITextMessage } from "../openai/openai_format.js";
@@ -64,7 +64,7 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
 
     async requestTextCompletion(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<Completion> {
         if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -82,7 +82,7 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         const result = choice.message.content;
 
         return {
-            result: result,
+            result: result ? [{ type: "text", value: result }] : [],
             token_usage: {
                 prompt: res.usage.prompt_tokens,
                 result: res.usage.completion_tokens,
@@ -93,9 +93,9 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         };
     }
 
-    async requestTextCompletionStream(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunk>> {
+    async requestTextCompletionStream(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
         if (options.model_options?._option_id !== "text-fallback") {
-            this.logger.warn("Invalid model options", {options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -115,8 +115,9 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
 
         return transformSSEStream(stream, (data: string) => {
             const json = JSON.parse(data);
+            const content = json.choices[0]?.delta.content;
             return {
-                result: json.choices[0]?.delta.content ?? '',
+                result: content ? [{ type: "text", value: content }] : [],
                 finish_reason: json.choices[0]?.finish_reason,      //Uses expected "stop" , "length" format
                 token_usage: {
                     prompt: json.usage?.prompt_tokens,
@@ -152,7 +153,7 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         const r = await this.client.post('/v1/embeddings', {
             payload: {
                 model,
-                input: [ text ],
+                input: [text],
                 encoding_format: "float"
             },
         });

package/src/openai/azure_openai.ts

@@ -9,7 +9,7 @@ export interface AzureOpenAIDriverOptions extends DriverOptions {
      * The credentials to use to access Azure OpenAI
      */
     azureADTokenProvider?: any; //type with azure credentials
-    
+
     apiKey?: string;
 
     endpoint?: string;
@@ -41,7 +41,7 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
 
         this.service = new AzureOpenAI({
             apiKey: opts.apiKey,
-            azureADTokenProvider: opts.azureADTokenProvider,          
+            azureADTokenProvider: opts.azureADTokenProvider,
             endpoint: opts.endpoint,
             apiVersion: opts.apiVersion ?? "2024-10-21",
             deployment: opts.deployment
@@ -56,7 +56,7 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
         const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
         return azureADTokenProvider;
     }
-    
+
     async listModels(): Promise<AIModel[]> {
         return this._listModels();
     }
@@ -65,7 +65,7 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
         if (!this.service.deploymentName) {
             throw new Error("A specific deployment is not set. Azure OpenAI cannot list deployments. Update your endpoint URL to include the deployment name, e.g., https://your-resource.openai.azure.com/openai/deployments/your-deployment/chat/completions");
         }
-            
+
         //Do a test execution to check if the model works and to get the model ID.
         let modelID = this.service.deploymentName;
         try {
@@ -76,7 +76,7 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
             });
             modelID = testResponse.model;
         } catch (error) {
-            this.logger.error("Failed to test model for Azure OpenAI listing :", error);
+            this.logger.error({ error }, "Failed to test model for Azure OpenAI listing :");
         }
         const modelCapability = getModelCapabilities(modelID, "openai");
         return [{

package/src/openai/index.ts

@@ -3,6 +3,7 @@ import {
     AbstractDriver,
     Completion,
     CompletionChunkObject,
+    CompletionResult,
     DataSource,
     DriverOptions,
     EmbeddingsOptions,
@@ -28,7 +29,12 @@ import OpenAI, { AzureOpenAI } from "openai";
 import { ChatCompletionMessageParam } from "openai/resources/chat/completions";
 import { Stream } from "openai/streaming";
 
-//TODO: Do we need a list?, replace with if statements and modernise?
+// Helper function to convert string to CompletionResult[]
+function textToCompletionResult(text: string): CompletionResult[] {
+    return text ? [{ type: "text", value: text }] : [];
+}
+
+//TODO: Do we need a list?, replace with if statements and modernize?
 const supportFineTunning = new Set([
     "gpt-3.5-turbo-1106",
     "gpt-3.5-turbo-0613",
@@ -70,21 +76,21 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         const data = choice.message.content ?? undefined;
 
         if (!data && !tools) {
-            this.logger?.error("[OpenAI] Response is not valid", result);
+            this.logger.error({ result }, "[OpenAI] Response is not valid");
             throw new Error("Response is not valid: no data");
         }
 
         return {
-            result: data,
+            result: textToCompletionResult(data || ''),
             token_usage: tokenInfo,
             finish_reason: openAiFinishReason(choice.finish_reason),
             tool_use: tools,
         };
     }
 
-    async requestTextCompletionStream(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<Completion>> {
+    async requestTextCompletionStream(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
         if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
-            this.logger.warn("Invalid model options", { options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
 
         const toolDefs = getToolDefinitions(options.tools);
@@ -99,7 +105,7 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             }
 
             return {
-                result: result,
+                result: textToCompletionResult(result),
                 finish_reason: openAiFinishReason(chunk.choices[0]?.finish_reason ?? undefined),         //Uses expected "stop" , "length" format
                 token_usage: {
                     prompt: chunk.usage?.prompt_tokens,
@@ -135,8 +141,6 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             reasoning_effort: model_options?.reasoning_effort,
             temperature: model_options?.temperature,
             top_p: model_options?.top_p,
-            //top_logprobs: options.top_logprobs,       //Logprobs output currently not supported
-            //logprobs: options.top_logprobs ? true : false,
             presence_penalty: model_options?.presence_penalty,
             frequency_penalty: model_options?.frequency_penalty,
             n: 1,
@@ -159,7 +163,7 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
 
     async requestTextCompletion(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<Completion> {
         if (options.model_options?._option_id !== "openai-text" && options.model_options?._option_id !== "openai-thinking") {
-            this.logger.warn("Invalid model options", { options: options.model_options });
+            this.logger.warn({ options: options.model_options }, "Invalid model options");
         }
 
         convertRoles(prompt, options.model);
@@ -192,8 +196,6 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
             reasoning_effort: model_options?.reasoning_effort,
             temperature: model_options?.temperature,
             top_p: model_options?.top_p,
-            //top_logprobs: options.top_logprobs,       //Logprobs output currently not supported
-            //logprobs: options.top_logprobs ? true : false,
             presence_penalty: model_options?.presence_penalty,
             frequency_penalty: model_options?.frequency_penalty,
             n: 1,
@@ -291,7 +293,7 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         //Some of these use the completions API instead of the chat completions API.
         //Others are for non-text input modalities. Therefore common to both.
         const wordBlacklist = ["embed", "whisper", "transcribe", "audio", "moderation", "tts",
-            "realtime", "dall-e", "babbage", "davinci", "codex", "o1-pro"];
+            "realtime", "dall-e", "babbage", "davinci", "codex", "o1-pro", "computer-use", "sora"];
 
 
         //OpenAI has very little information, filtering based on name.
@@ -302,11 +304,15 @@ export abstract class BaseOpenAIDriver extends AbstractDriver<
         const models = filter ? result.filter(filter) : result;
         const aiModels = models.map((m) => {
             const modelCapability = getModelCapabilities(m.id, "openai");
+            let owner = m.owned_by;
+            if (owner == "system") {
+                owner = "openai";
+            }
             return {
                 id: m.id,
                 name: m.id,
                 provider: this.provider,
-                owner: m.owned_by,
+                owner: owner,
                 type: m.object === "model" ? ModelType.Text : ModelType.Unknown,
                 can_stream: true,
                 is_multimodal: m.id.includes("gpt-4"),