@llumiverse/drivers 0.20.0 → 0.21.0

package/src/azure/azure_foundry.ts

@@ -0,0 +1,450 @@
+import { DefaultAzureCredential, getBearerTokenProvider, TokenCredential } from "@azure/identity";
+import { AbstractDriver, AIModel, Completion, CompletionChunk, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, getModelCapabilities, modelModalitiesToArray, Providers } from "@llumiverse/core";
+import { AIProjectClient, DeploymentUnion, ModelDeployment } from '@azure/ai-projects';
+import { isUnexpected } from "@azure-rest/ai-inference";
+import { ChatCompletionMessageParam } from "openai/resources";
+import type {
+    ChatCompletionsOutput,
+    ChatCompletionsToolCall,
+    ChatRequestMessage,
+} from "@azure-rest/ai-inference";
+import { AzureOpenAIDriver } from "../openai/azure_openai.js";
+import { createSseStream, NodeJSReadableStream } from "@azure/core-sse";
+import { formatOpenAILikeMultimodalPrompt } from "../openai/openai_format.js";
+export interface AzureFoundryDriverOptions extends DriverOptions {
+    /**
+     * The credentials to use to access Azure AI Foundry
+     */
+    azureADTokenProvider?: TokenCredential;
+
+    endpoint?: string;
+
+    apiVersion?: string;
+}
+
+export interface AzureFoundryInferencePrompt {
+    messages: ChatRequestMessage[];
+}
+
+export interface AzureFoundryOpenAIPrompt {
+    messages: ChatCompletionMessageParam[]
+}
+
+export type AzureFoundryPrompt = AzureFoundryInferencePrompt | AzureFoundryOpenAIPrompt
+
+export class AzureFoundryDriver extends AbstractDriver<AzureFoundryDriverOptions, ChatCompletionMessageParam[]> {
+    service: AIProjectClient;
+    readonly provider = Providers.azure_foundry;
+
+    OPENAI_API_VERSION = "2025-01-01-preview";
+    INFERENCE_API_VERSION = "2024-05-01-preview";
+
+    constructor(opts: AzureFoundryDriverOptions) {
+        super(opts);
+
+        this.formatPrompt = formatOpenAILikeMultimodalPrompt;
+
+        if (!opts.endpoint) {
+            throw new Error("Azure AI Foundry endpoint is required");
+        }
+
+        try {
+            if (!opts.azureADTokenProvider) {
+                // Using Microsoft Entra ID (Azure AD) for authentication
+                opts.azureADTokenProvider = new DefaultAzureCredential();
+            }
+        } catch (error) {
+            this.logger.error("Failed to initialize Azure AD token provider:", error);
+            throw new Error("Failed to initialize Azure AD token provider");
+        }
+
+        // Initialize AI Projects client which provides access to inference operations
+        this.service = new AIProjectClient(
+            opts.endpoint,
+            opts.azureADTokenProvider
+        );
+
+        if (opts.apiVersion) {
+            this.OPENAI_API_VERSION = opts.apiVersion;
+            this.INFERENCE_API_VERSION = opts.apiVersion;
+            this.logger.info(`[Azure Foundry] Overriding default API version, using API version: ${opts.apiVersion}`);
+        }
+    }
+
+    /**
+     * Get default authentication for Azure AI Foundry API
+     */
+    getDefaultAIFoundryAuth() {
+        const scope = "https://ai.azure.com/.default";
+        const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
+        return azureADTokenProvider;
+    }
+
+    async isOpenAIDeployment(model: string): Promise<boolean> {
+        const { deploymentName } = parseAzureFoundryModelId(model);
+
+        let deployment = undefined;
+        // First, verify the deployment exists
+        try {
+            deployment = await this.service.deployments.get(deploymentName);
+            this.logger.debug(`[Azure Foundry] Deployment ${deploymentName} found`);
+        } catch (deploymentError) {
+            this.logger.error(`[Azure Foundry] Deployment ${deploymentName} not found:`, deploymentError);
+        }
+
+        return (deployment as ModelDeployment).modelPublisher == "OpenAI";
+    }
+
+    protected canStream(_options: ExecutionOptions): Promise<boolean> {
+        return Promise.resolve(true);
+    }
+
+    async requestTextCompletion(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<Completion> {
+        const { deploymentName } = parseAzureFoundryModelId(options.model);
+        const model_options = options.model_options as any;
+        const isOpenAI = await this.isOpenAIDeployment(options.model);
+
+        let response;
+        if (isOpenAI) {
+            // Use the Azure OpenAI client for OpenAI models
+            const azureOpenAI = await this.service.inference.azureOpenAI({ apiVersion: this.OPENAI_API_VERSION });
+            const subDriver = new AzureOpenAIDriver(azureOpenAI);
+            // Use deployment name for API calls
+            const modifiedOptions = { ...options, model: deploymentName };
+            const response = await subDriver.requestTextCompletion(prompt, modifiedOptions);
+            return response;
+
+        } else {
+            // Use the chat completions client from the inference operations
+            const chatClient = this.service.inference.chatCompletions({ apiVersion: this.INFERENCE_API_VERSION });
+            response = await chatClient.post({
+                body: {
+                    messages: prompt,
+                    max_tokens: model_options?.max_tokens,
+                    model: deploymentName,
+                    stream: true,
+                    temperature: model_options?.temperature,
+                    top_p: model_options?.top_p,
+                    frequency_penalty: model_options?.frequency_penalty,
+                    presence_penalty: model_options?.presence_penalty,
+                    stop: model_options?.stop_sequence,
+                }
+            });
+            if (response.status !== "200") {
+                this.logger.error(`[Azure Foundry] Chat completion request failed:`, response);
+                throw new Error(`Chat completion request failed with status ${response.status}: ${response.body}`);
+            }
+
+            return this.extractDataFromResponse(response.body as ChatCompletionsOutput);
+        }
+    }
+
+    async requestTextCompletionStream(prompt: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunk>> {
+        const { deploymentName } = parseAzureFoundryModelId(options.model);
+        const model_options = options.model_options as any;
+        const isOpenAI = await this.isOpenAIDeployment(options.model);
+
+        if (isOpenAI) {
+            const azureOpenAI = await this.service.inference.azureOpenAI({ apiVersion: this.OPENAI_API_VERSION });
+            const subDriver = new AzureOpenAIDriver(azureOpenAI);
+            const modifiedOptions = { ...options, model: deploymentName };
+            const stream = await subDriver.requestTextCompletionStream(prompt, modifiedOptions);
+            return stream;
+        } else {
+            const chatClient = this.service.inference.chatCompletions({ apiVersion: this.INFERENCE_API_VERSION });
+            const response = await chatClient.post({
+                body: {
+                    messages: prompt,
+                    max_tokens: model_options?.max_tokens,
+                    model: deploymentName,
+                    stream: true,
+                    temperature: model_options?.temperature,
+                    top_p: model_options?.top_p,
+                    frequency_penalty: model_options?.frequency_penalty,
+                    presence_penalty: model_options?.presence_penalty,
+                    stop: model_options?.stop_sequence,
+                }
+            }).asNodeStream();
+
+            // We type assert from NodeJS.ReadableStream to NodeJSReadableStream
+            // The Azure Examples, expect a .destroy() method on the stream
+            const stream = response.body as NodeJSReadableStream;
+            if (!stream) {
+                throw new Error("The response stream is undefined");
+            }
+
+            if (response.status !== "200") {
+                stream.destroy();
+                throw new Error(`Failed to get chat completions, http operation failed with ${response.status} code`);
+            }
+
+            const sseStream = createSseStream(stream);
+
+            return this.processStreamResponse(sseStream);
+        }
+    }
+
+    private async *processStreamResponse(sseStream: any): AsyncIterable<CompletionChunk> {
+        try {
+            for await (const event of sseStream) {
+                if (event.data === "[DONE]") {
+                    break;
+                }
+
+                try {
+                    const data = JSON.parse(event.data);
+                    const choice = data.choices?.[0];
+
+                    if (!choice) {
+                        continue;
+                    }
+                    const chunk: CompletionChunk = {
+                        result: choice.delta?.content || "",
+                        finish_reason: this.convertFinishReason(choice.finish_reason),
+                    };
+
+                    yield chunk;
+                } catch (parseError) {
+                    this.logger.warn(`[Azure Foundry] Failed to parse streaming response:`, parseError);
+                    continue;
+                }
+            }
+        } catch (error) {
+            this.logger.error(`[Azure Foundry] Streaming error:`, error);
+            throw error;
+        }
+    }
+
+
+    private extractDataFromResponse(result: ChatCompletionsOutput): Completion {
+        const tokenInfo = {
+            prompt: result.usage?.prompt_tokens,
+            result: result.usage?.completion_tokens,
+            total: result.usage?.total_tokens,
+        };
+
+        const choice = result.choices?.[0];
+        if (!choice) {
+            this.logger?.error("[Azure Foundry] No choices in response", result);
+            throw new Error("No choices in response");
+        }
+
+        const data = choice.message?.content;
+        const toolCalls = choice.message?.tool_calls;
+
+        if (!data && !toolCalls) {
+            this.logger?.error("[Azure Foundry] Response is not valid", result);
+            throw new Error("Response is not valid: no content or tool calls");
+        }
+
+        const completion: Completion = {
+            result: data,
+            token_usage: tokenInfo,
+            finish_reason: this.convertFinishReason(choice.finish_reason),
+        };
+
+        if (toolCalls && toolCalls.length > 0) {
+            completion.tool_use = toolCalls.map((call: ChatCompletionsToolCall) => ({
+                id: call.id,
+                tool_name: call.function?.name,
+                tool_input: call.function?.arguments ? JSON.parse(call.function.arguments) : {}
+            }));
+        }
+
+        return completion;
+    }
+
+    private convertFinishReason(reason: string | null | undefined): string | undefined {
+        if (!reason) return undefined;
+        // Map Azure AI finish reasons to standard format
+        switch (reason) {
+            case 'stop': return 'stop';
+            case 'length': return 'length';
+            case 'tool_calls': return 'tool_use';
+            default: return reason;
+        }
+    }
+
+    async validateConnection(): Promise<boolean> {
+        try {
+            // Test the AI Projects client by listing deployments
+            const deploymentsIterable = this.service.deployments.list();
+            let hasDeployments = false;
+
+            for await (const deployment of deploymentsIterable) {
+                hasDeployments = true;
+                this.logger.debug(`[Azure Foundry] Found deployment: ${deployment.name} (${deployment.type})`);
+                break; // Just check if we can get at least one deployment
+            }
+
+            if (!hasDeployments) {
+                this.logger.warn("[Azure Foundry] No deployments found in the project");
+            }
+
+            return true;
+        } catch (error) {
+            this.logger.error("Azure Foundry connection validation failed:", error);
+            return false;
+        }
+    }
+
+    async generateEmbeddings(options: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        if (!options.model) {
+            throw new Error("Default embedding model selection not supported for Azure Foundry. Please specify a model.");
+        }
+
+        if (options.text) {
+            return this.generateTextEmbeddings(options);
+        } else if (options.image) {
+            return this.generateImageEmbeddings(options);
+        } else {
+            throw new Error("No text or images provided for embeddings");
+        }
+    }
+
+    async generateTextEmbeddings(options: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        if (!options.text) {
+            throw new Error("No text provided for text embeddings");
+        }
+
+        const { deploymentName } = parseAzureFoundryModelId(options.model || "");
+
+        let response;
+        try {
+            // Use the embeddings client from the inference operations
+            const embeddingsClient = this.service.inference.embeddings({ apiVersion: this.INFERENCE_API_VERSION });
+            response = await embeddingsClient.post({
+                body: {
+                    input: Array.isArray(options.text) ? options.text : [options.text],
+                    model: deploymentName
+                }
+            });
+        } catch (error) {
+            this.logger.error("Azure Foundry text embeddings error:", error);
+            throw error;
+        }
+
+        if (isUnexpected(response)) {
+            throw new Error(`Text embeddings request failed: ${response.status} ${response.body?.error?.message || 'Unknown error'}`);
+        }
+
+        const embeddings = response.body.data?.[0]?.embedding;
+        if (!embeddings || !Array.isArray(embeddings) || embeddings.length === 0) {
+            throw new Error("No valid embedding array found in response");
+        }
+
+        return {
+            values: embeddings,
+            model: options.model ?? ""
+        };
+    }
+
+    async generateImageEmbeddings(options: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        if (!options.image) {
+            throw new Error("No images provided for image embeddings");
+        }
+
+        const { deploymentName } = parseAzureFoundryModelId(options.model || "");
+
+        let response;
+        try {
+            // Use the embeddings client from the inference operations
+            const embeddingsClient = this.service.inference.embeddings({ apiVersion: this.INFERENCE_API_VERSION });
+            response = await embeddingsClient.post({
+                body: {
+                    input: Array.isArray(options.image) ? options.image : [options.image],
+                    model: deploymentName
+                }
+            });
+        } catch (error) {
+            this.logger.error("Azure Foundry image embeddings error:", error);
+            throw error;
+        }
+        if (isUnexpected(response)) {
+            throw new Error(`Image embeddings request failed: ${response.status} ${response.body?.error?.message || 'Unknown error'}`);
+        }
+        const embeddings = response.body.data?.[0]?.embedding;
+        if (!embeddings || !Array.isArray(embeddings) || embeddings.length === 0) {
+            throw new Error("No valid embedding array found in response");
+        }
+        return {
+            values: embeddings,
+            model: options.model ?? ""
+        };
+    }
+
+    async listModels(): Promise<AIModel[]> {
+        const filter = (m: ModelDeployment) => {
+            // Only include models that support chat completions
+            return !!m.capabilities.chat_completion;
+        };
+        return this._listModels(filter);
+    }
+
+    async _listModels(filter?: (m: ModelDeployment) => boolean): Promise<AIModel[]> {
+        let deploymentsIterable;
+        try {
+            // List all deployments in the Azure AI Foundry project
+            deploymentsIterable = this.service.deployments.list();
+        } catch (error) {
+            this.logger.error("Failed to list deployments:", error);
+            throw new Error("Failed to list deployments in Azure AI Foundry project");
+        }
+        const deployments: DeploymentUnion[] = [];
+
+        for await (const page of deploymentsIterable.byPage()) {
+            for (const deployment of page) {
+                deployments.push(deployment);
+            }
+        }
+
+        let modelDeployments: ModelDeployment[] = deployments.filter((d): d is ModelDeployment => {
+            return d.type === "ModelDeployment";
+        });
+
+        if (filter) {
+            modelDeployments = modelDeployments.filter(filter);
+        }
+
+        const aiModels = modelDeployments.map((model) => {
+            // Create composite ID: deployment_name::base_model
+            const compositeId = `${model.name}::${model.modelName}`;
+
+            const modelCapability = getModelCapabilities(model.modelName, Providers.azure_foundry);
+            return {
+                id: compositeId,
+                name: model.name,
+                description: `${model.modelName} - ${model.modelVersion}`,
+                version: model.modelVersion,
+                provider: this.provider,
+                owner: model.modelPublisher,
+                input_modalities: modelModalitiesToArray(modelCapability.input),
+                output_modalities: modelModalitiesToArray(modelCapability.output),
+                tool_support: modelCapability.tool_support,
+            } satisfies AIModel<string>;
+        }).sort((modelA, modelB) => modelA.id.localeCompare(modelB.id));
+
+        return aiModels;
+    }
+}
+
+// Helper functions to parse the composite ID
+export function parseAzureFoundryModelId(compositeId: string): { deploymentName: string; baseModel: string } {
+    const parts = compositeId.split('::');
+    if (parts.length === 2) {
+        return {
+            deploymentName: parts[0],
+            baseModel: parts[1]
+        };
+    }
+
+    // Backwards compatibility: if no delimiter found, treat as deployment name
+    return {
+        deploymentName: compositeId,
+        baseModel: compositeId
+    };
+}
+
+export function isCompositeModelId(modelId: string): boolean {
+    return modelId.includes('::');
+}

package/src/bedrock/index.ts

@@ -74,11 +74,13 @@ function maxTokenFallbackClaude(option: StatelessExecutionOptions): number {
     if (modelOptions && typeof modelOptions.max_tokens === "number") {
         return modelOptions.max_tokens;
     } else {
+        const thinking_budget = modelOptions?.thinking_budget_tokens ?? 0;
+        let maxSupportedTokens = getMaxTokensLimitBedrock(option.model) ?? 8192; // Should always return a number for claude, 8192 is to satisfy the TypeScript type checker;
         // Fallback to the default max tokens limit for the model
-        if (option.model.includes('claude-3-7-sonnet') && (modelOptions?.thinking_budget_tokens ?? 0) < 64000) {
-            return 64000; // Claude 3.7 can go up to 128k with a beta header, but when no max tokens is specified, we default to 64k.
+        if (option.model.includes('claude-3-7-sonnet') && (modelOptions?.thinking_budget_tokens ?? 0) < 48000) {
+            maxSupportedTokens = 64000; // Claude 3.7 can go up to 128k with a beta header, but when no max tokens is specified, we default to 64k.
         }
-        return getMaxTokensLimitBedrock(option.model) ?? 8192; // Should always return a number for claude, 8192 is to satisfy the TypeScript type checker
+        return Math.min(16000 + thinking_budget, maxSupportedTokens); // Cap to 16k, to avoid taking up too much context window and quota.
     }
 }
 
@@ -380,7 +382,7 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
             });
 
         }).catch((err) => {
-            this.logger.error("[Bedrock] Failed to stream", err);
+            this.logger.error("[Bedrock] Failed to stream", { error: err });
             throw err;
         });
     }
@@ -737,7 +739,6 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                 id: m.modelArn ?? m.modelId,
                 name: `${m.providerName} ${m.modelName}`,
                 provider: this.provider,
-                //description: ``,
                 owner: m.providerName,
                 can_stream: m.responseStreamingSupported ?? false,
                 input_modalities: m.inputModalities ? formatAmazonModalities(m.inputModalities) : modelModalitiesToArray(modelCapability.input),
@@ -762,6 +763,7 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                     id: m.modelArn,
                     name: m.modelName ?? m.modelArn,
                     provider: this.provider,
+                    owner: "custom",
                     description: `Custom model from ${m.baseModelName}`,
                     is_custom: true,
                     input_modalities: modelModalitiesToArray(modelCapability.input),
@@ -801,6 +803,7 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                         id: p.inferenceProfileArn ?? p.inferenceProfileId,
                         name: p.inferenceProfileName ?? p.inferenceProfileArn,
                         provider: this.provider,
+                        owner: providerName,
                         input_modalities: modelModalitiesToArray(modelCapability.input),
                         output_modalities: modelModalitiesToArray(modelCapability.output),
                         tool_support: modelCapability.tool_support,

package/src/groq/index.ts

@@ -1,16 +1,16 @@
 import { AIModel, AbstractDriver, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
 import { transformAsyncIterator } from "@llumiverse/core/async";
-import { OpenAITextMessage, formatOpenAILikeTextPrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
-import Groq from "groq-sdk";
+import { formatOpenAILikeMultimodalPrompt } from "../openai/openai_format.js";
 
+import Groq from "groq-sdk";
+import type { ChatCompletionMessageParam } from "groq-sdk/resources/chat/completions";
 
 interface GroqDriverOptions extends DriverOptions {
     apiKey: string;
     endpoint_url?: string;
 }
 
-
-export class GroqDriver extends AbstractDriver<GroqDriverOptions, OpenAITextMessage[]> {
+export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletionMessageParam[]> {
     static PROVIDER = "groq";
     provider = GroqDriver.PROVIDER;
     apiKey: string;
@@ -46,19 +46,110 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, OpenAITextMess
         return undefined;
     }
 
-    protected async formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<OpenAITextMessage[]> {
-        const messages = formatOpenAILikeTextPrompt(segments);
-        //Add JSON instruction is schema is provided
-        if (opts.result_schema) {
-            messages.push({
-                role: "user",
-                content: "IMPORTANT: " + getJSONSafetyNotice(opts.result_schema)
-            });
-        }
-        return messages;
+    protected async formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<ChatCompletionMessageParam[]> {
+        // Use OpenAI's multimodal formatter as base then convert to Groq types
+        const openaiMessages = await formatOpenAILikeMultimodalPrompt(segments, {
+            ...opts,
+            multimodal: true,
+        });
+        
+        // Convert OpenAI ChatCompletionMessageParam[] to Groq ChatCompletionMessageParam[]
+        // Handle differences between OpenAI and Groq SDK types
+        const groqMessages: ChatCompletionMessageParam[] = openaiMessages.map(msg => {
+            // Handle OpenAI developer messages - convert to system messages for Groq
+            if (msg.role === 'developer' || msg.role === 'system') {
+                const systemMsg: ChatCompletionMessageParam = {
+                    role: 'system',
+                    content: Array.isArray(msg.content) 
+                        ? msg.content.map(part => part.text).join('\n')
+                        : msg.content,
+                    // Preserve name if present
+                    ...(msg.name && { name: msg.name })
+                };
+                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;
+                
+                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 => 
+                        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, 
+                                image_url: {
+                                    url: part.image_url.url,
+                                    ...(part.image_url.detail && { detail: part.image_url.detail })
+                                }
+                            };
+                        }
+                        return null;
+                    }).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 ?? "",
+                    // Preserve name if present
+                    ...(msg.name && { name: msg.name })
+                };
+                return userMsg;
+            }
+            
+            // Handle assistant messages - handle content arrays if needed
+            if (msg.role === 'assistant') {
+                const assistantMsg: ChatCompletionMessageParam = {
+                    role: 'assistant',
+                    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) 
+                        ? msg.content.map(part => part.text).join('\n')
+                        : msg.content
+                };
+                return toolMsg;
+            }
+            
+            if (msg.role === 'function') {
+                const functionMsg: ChatCompletionMessageParam = {
+                    role: 'function',
+                    name: msg.name,
+                    content: msg.content
+                };
+                return functionMsg;
+            }
+            
+            // Fallback - should not reach here but provides type safety
+            throw new Error(`Unsupported message role: ${(msg as any).role}`);
+        });
+
+        return groqMessages;
     }
 
-    async requestTextCompletion(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<Completion<any>> {
+    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 });
         }
@@ -93,7 +184,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, OpenAITextMess
         };
     }
 
-    async requestTextCompletionStream(messages: OpenAITextMessage[], 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 });
         }

package/src/index.ts

@@ -2,7 +2,8 @@ export * from "./bedrock/index.js";
 export * from "./groq/index.js";
 export * from "./huggingface_ie.js";
 export * from "./mistral/index.js";
-export * from "./openai/azure.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";

package/src/mistral/index.ts

@@ -1,6 +1,7 @@
 import { AIModel, AbstractDriver, Completion, CompletionChunk, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
 import { transformSSEStream } from "@llumiverse/core/async";
-import { OpenAITextMessage, formatOpenAILikeTextPrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
+import { getJSONSafetyNotice } from "@llumiverse/core/formatters";
+import { formatOpenAILikeTextPrompt, OpenAITextMessage } from "../openai/openai_format.js";
 import { FetchClient } from "@vertesia/api-fetch-client";
 import { ChatCompletionResponse, CompletionRequestParams, ListModelsResponse, ResponseFormat } from "./types.js";
 
@@ -61,7 +62,7 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         return messages;
     }
 
-    async requestTextCompletion(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<Completion<any>> {
+    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 });
         }