@llumiverse/drivers 1.3.0 → 1.4.0

package/src/huggingface_ie.ts

@@ -1,19 +1,16 @@
+import { InferenceClient, type TextGenerationStreamOutput } from '@huggingface/inference';
 import {
-    InferenceClient,
-    TextGenerationStreamOutput,
-} from "@huggingface/inference";
-import {
-    AbstractDriver,
-    AIModel,
+    type AIModel,
     AIModelStatus,
-    CompletionChunkObject,
-    DriverOptions,
-    EmbeddingsResult,
-    ExecutionOptions,
-    TextFallbackOptions,
-} from "@llumiverse/core";
-import { transformAsyncIterator } from "@llumiverse/core/async";
-import { FetchClient } from "@vertesia/api-fetch-client";
+    type CompletionChunkObject,
+    type DriverOptions,
+    type EmbeddingsResult,
+    type ExecutionOptions,
+    type TextFallbackOptions,
+} from '@llumiverse/core';
+import { transformAsyncIterator } from '@llumiverse/core/async';
+import { AbstractDriver } from '@llumiverse/core/driver';
+import { FetchClient } from '@vertesia/api-fetch-client';
 
 export interface HuggingFaceIEDriverOptions extends DriverOptions {
     apiKey: string;
@@ -21,25 +18,21 @@ export interface HuggingFaceIEDriverOptions extends DriverOptions {
 }
 
 export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptions, string> {
-    static PROVIDER = "huggingface_ie";
+    static PROVIDER = 'huggingface_ie';
     provider = HuggingFaceIEDriver.PROVIDER;
     service: FetchClient;
     _executor?: InferenceClient;
 
-    constructor(
-        options: HuggingFaceIEDriverOptions
-    ) {
+    constructor(options: HuggingFaceIEDriverOptions) {
         super(options);
         if (!options.endpoint_url) {
             throw new Error(`Endpoint URL is required for ${this.provider}`);
         }
-        this.service = new FetchClient(this.options.endpoint_url);
-        this.service.headers["Authorization"] = `Bearer ${this.options.apiKey}`;
+        this.service = new FetchClient(this.options.endpoint_url, this.getDriverFetch());
+        this.service.headers.Authorization = `Bearer ${this.options.apiKey}`;
     }
 
-    async getModelURLEndpoint(
-        modelId: string
-    ): Promise<{ url: string; status: string; }> {
+    async getModelURLEndpoint(modelId: string): Promise<{ url: string; status: string }> {
         const res = (await this.service.get(`/${modelId}`)) as HuggingFaceIEModel;
         return {
             url: res.status.url,
@@ -50,26 +43,19 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
     async getExecutor(model: string) {
         if (!this._executor) {
             const endpoint = await this.getModelURLEndpoint(model);
-            if (!endpoint.url)
-                throw new Error(
-                    `Endpoint URL not found for model ${model}`
-                );
+            if (!endpoint.url) throw new Error(`Endpoint URL not found for model ${model}`);
             if (endpoint.status !== AIModelStatus.Available)
-                throw new Error(
-                    `Endpoint ${model} is not running - current status: ${endpoint.status}`
-                );
+                throw new Error(`Endpoint ${model} is not running - current status: ${endpoint.status}`);
 
             // Use the new InferenceClient and bind it to the endpoint URL
-            this._executor = new InferenceClient(this.options.apiKey).endpoint(
-                endpoint.url
-            );
+            this._executor = new InferenceClient(this.options.apiKey).endpoint(endpoint.url);
         }
         return this._executor;
     }
 
     async requestTextCompletionStream(prompt: string, options: ExecutionOptions) {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        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;
 
@@ -86,22 +72,22 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
             //special like <s> are not part of the result
             if (val.token.special) return { result: [] };
             let finish_reason = val.details?.finish_reason as string;
-            if (finish_reason === "eos_token") {
-                finish_reason = "stop";
+            if (finish_reason === 'eos_token') {
+                finish_reason = 'stop';
             }
             return {
-                result: val.token.text ? [{ type: "text" as const, value: 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,
-                }
+                },
             };
         });
     }
 
     async requestTextCompletion(prompt: string, options: ExecutionOptions) {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        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;
 
@@ -115,26 +101,25 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
         });
 
         let finish_reason = res.details?.finish_reason as string;
-        if (finish_reason === "eos_token") {
-            finish_reason = "stop";
+        if (finish_reason === 'eos_token') {
+            finish_reason = 'stop';
         }
         return {
-            result: [{ type: "text" as const, value: res.generated_text }],
+            result: [{ type: 'text' as const, value: res.generated_text }],
             finish_reason: finish_reason,
             token_usage: {
-                result: res.details?.generated_tokens
+                result: res.details?.generated_tokens,
             },
             original_response: options.include_original_response ? res : undefined,
         };
-
     }
 
     // ============== management API ==============
 
     async listModels(): Promise<AIModel[]> {
-        const res = await this.service.get("/");
-        const hfModels = res.items as HuggingFaceIEModel[];
-        if (!hfModels || !hfModels.length) return [];
+        const res = (await this.service.get('/')) as { items: HuggingFaceIEModel[] };
+        const hfModels = res.items;
+        if (!hfModels?.length) return [];
 
         const models: AIModel[] = hfModels.map((model: HuggingFaceIEModel) => ({
             id: model.name,
@@ -149,36 +134,35 @@ export class HuggingFaceIEDriver extends AbstractDriver<HuggingFaceIEDriverOptio
 
     async validateConnection(): Promise<boolean> {
         try {
-            await this.service.get("/models");
+            await this.service.get('/models');
             return true;
-        } catch (error) {
+        } catch {
             return false;
         }
     }
 
     async generateEmbeddings(): Promise<EmbeddingsResult> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
-
 }
 
 //get status from HF status
 function getStatus(hfModel: HuggingFaceIEModel): AIModelStatus {
     //[ pending, initializing, updating, updateFailed, running, paused, failed, scaledToZero ]
     switch (hfModel.status.state) {
-        case "running":
+        case 'running':
             return AIModelStatus.Available;
-        case "initializing":
+        case 'initializing':
             return AIModelStatus.Pending;
-        case "updating":
+        case 'updating':
             return AIModelStatus.Pending;
-        case "updateFailed":
+        case 'updateFailed':
             return AIModelStatus.Unavailable;
-        case "paused":
+        case 'paused':
             return AIModelStatus.Stopped;
-        case "failed":
+        case 'failed':
             return AIModelStatus.Unavailable;
-        case "scaledToZero":
+        case 'scaledToZero':
             return AIModelStatus.Available;
         default:
             return AIModelStatus.Unknown;
@@ -199,7 +183,7 @@ interface HuggingFaceIEModel {
     model: {
         framework: string;
         image: {
-            huggingface: {};
+            huggingface: Record<string, never>;
         };
         repository: string;
         revision: string;

package/src/index.ts

@@ -1,16 +1,15 @@
-export * from "./anthropic/index.js";
-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 "./openai/openai.js";
-export * from "./openai/openai_compatible.js";
-export * from "./replicate.js";
-export * from "./test-driver/index.js";
-export * from "./togetherai/index.js";
-export * from "./vertexai/index.js";
-export * from "./watsonx/index.js";
-export * from "./xai/index.js";
-
+export * from './anthropic/index.js';
+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 './openai/openai.js';
+export * from './openai/openai_compatible.js';
+export * from './replicate.js';
+export * from './test-driver/index.js';
+export * from './togetherai/index.js';
+export * from './vertexai/index.js';
+export * from './watsonx/index.js';
+export * from './xai/index.js';

package/src/mistral/index.ts

@@ -1,9 +1,29 @@
-import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions } from "@llumiverse/core";
-import { transformSSEStream } from "@llumiverse/core/async";
-import { getJSONSafetyNotice } from "@llumiverse/core/formatters";
-import { FetchClient } from "@vertesia/api-fetch-client";
-import { formatOpenAILikeTextPrompt, OpenAITextMessage } from "../openai/openai_format.js";
-import { ChatCompletionResponse, CompletionRequestParams, ListModelsResponse, ResponseFormat } from "./types.js";
+import {
+    type AIModel,
+    type Completion,
+    type CompletionChunkObject,
+    type DriverOptions,
+    type EmbeddingsOptions,
+    type EmbeddingsResult,
+    type ExecutionOptions,
+    LlumiverseError,
+    MISTRAL_DEFAULT_EMBEDDING_MODEL,
+    normalizeEmbeddingsOptions,
+    type PromptSegment,
+    type TextFallbackOptions,
+} from '@llumiverse/core';
+import { transformSSEStream } from '@llumiverse/core/async';
+import { AbstractDriver } from '@llumiverse/core/driver';
+import { getJSONSafetyNotice } from '@llumiverse/core/formatters';
+import { FetchClient, type ServerSentEvent } from '@vertesia/api-fetch-client';
+import { formatOpenAILikeTextPrompt, type OpenAITextMessage } from '../openai/openai_format.js';
+import type {
+    ChatCompletionResponse,
+    CompletionRequestParams,
+    EmbeddingResponse,
+    ListModelsResponse,
+    ResponseFormat,
+} from './types.js';
 
 //TODO retry on 429
 //const RETRY_STATUS_CODES = [429, 500, 502, 503, 504];
@@ -16,7 +36,7 @@ interface MistralAIDriverOptions extends DriverOptions {
 }
 
 export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, OpenAITextMessage[]> {
-    static PROVIDER = "mistralai";
+    static PROVIDER = 'mistralai';
 
     provider = MistralAIDriver.PROVIDER;
     apiKey: string;
@@ -27,13 +47,12 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         super(options);
         this.apiKey = options.apiKey;
         //this.client = new MistralClient(options.apiKey, options.endpointUrl);
-        this.client = new FetchClient(options.endpoint_url || ENDPOINT).withHeaders({
-            authorization: `Bearer ${this.apiKey}`
+        this.client = new FetchClient(options.endpoint_url || ENDPOINT, this.getDriverFetch()).withHeaders({
+            authorization: `Bearer ${this.apiKey}`,
         });
     }
 
     getResponseFormat = (_options: ExecutionOptions): ResponseFormat | undefined => {
-
         // const responseFormatJson: ResponseFormat = {
         //     type: "json_object",
         // } as ResponseFormat
@@ -42,29 +61,28 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         //     type: "text",
         // } as ResponseFormat;
 
-
         // return _options.result_schema ? responseFormatJson : responseFormatText;
 
         //TODO remove this when Mistral properly supports the parameters - it makes an error for now
         // some models like mixtral mistral tiny or medium are throwing an error when using the response_format parameter
-        return undefined
-    }
+        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)
+                role: 'user',
+                content: `IMPORTANT: ${getJSONSafetyNotice(opts.result_schema)}`,
             });
         }
         return messages;
     }
 
     async requestTextCompletion(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        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;
 
@@ -75,30 +93,33 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
             temperature: options.model_options?.temperature,
             responseFormat: this.getResponseFormat(options),
         });
-        this.logger.debug({ payload: JSON.stringify(requestPayload) }, "Mistral request payload");
+        this.logger.debug({ payload: JSON.stringify(requestPayload) }, 'Mistral request payload');
 
-        const res = await this.client.post('/v1/chat/completions', {
+        const res = (await this.client.post('/v1/chat/completions', {
             payload: requestPayload,
-        }) as ChatCompletionResponse;
+        })) as ChatCompletionResponse;
 
         const choice = res.choices[0];
         const result = choice.message.content;
 
         return {
-            result: result ? [{ type: "text", value: 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,        //Uses expected "stop" , "length" format
+            finish_reason: choice.finish_reason, //Uses expected "stop" , "length" format
             original_response: options.include_original_response ? res : undefined,
         };
     }
 
-    async requestTextCompletionStream(messages: OpenAITextMessage[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+    async requestTextCompletionStream(
+        messages: OpenAITextMessage[],
+        options: ExecutionOptions,
+    ): Promise<AsyncIterable<CompletionChunkObject>> {
+        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;
 
@@ -112,19 +133,19 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
             stream: true,
             stopSequences: options.model_options?.stop_sequence,
         });
-        this.logger.debug({ payload: JSON.stringify(streamPayload) }, "Mistral stream request payload");
+        this.logger.debug({ payload: JSON.stringify(streamPayload) }, 'Mistral stream request payload');
 
-        const stream = await this.client.post('/v1/chat/completions', {
+        const stream = (await this.client.post('/v1/chat/completions', {
             payload: streamPayload,
-            reader: 'sse'
-        });
+            reader: 'sse',
+        })) as ReadableStream<ServerSentEvent>;
 
         return transformSSEStream(stream, (data: string) => {
             const json = JSON.parse(data);
             const content = json.choices[0]?.delta.content;
             return {
-                result: content ? [{ type: "text", value: content }] : [],
-                finish_reason: json.choices[0]?.finish_reason,      //Uses expected "stop" , "length" format
+                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,
                     result: json.usage?.completion_tokens,
@@ -132,44 +153,72 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
                 },
             };
         });
-
     }
 
     async listModels(): Promise<AIModel<string>[]> {
         const models: ListModelsResponse = await this.client.get('v1/models');
 
-        const aiModels = models.data.map(m => {
+        const aiModels = models.data.map((m) => {
             return {
                 id: m.id,
                 name: m.id,
                 description: undefined,
                 provider: this.provider,
                 owner: m.owned_by,
-            }
+            };
         });
 
         return aiModels;
     }
 
     validateConnection(): Promise<boolean> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
-    async generateEmbeddings({ text, model = "mistral-embed" }: EmbeddingsOptions): Promise<EmbeddingsResult> {
-        const r = await this.client.post('/v1/embeddings', {
-            payload: {
-                model,
-                input: [text],
-                encoding_format: "float"
-            },
+    async generateEmbeddings(options: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        const normalized = normalizeEmbeddingsOptions(options);
+        const model = normalized.model ?? MISTRAL_DEFAULT_EMBEDDING_MODEL;
+        const texts = normalized.inputs.map((input) => {
+            if (input.type !== 'text') {
+                throw new Error(
+                    `Provider 'mistralai' does not support '${input.type}' embeddings; only 'text' is supported.`,
+                );
+            }
+            return input.text;
         });
-        return {
-            values: r.data[0].embedding,
-            model,
-            token_count: r.usage.total_tokens || r.usage.prompt_tokens + r.usage.completion_tokens,
+
+        try {
+            const r = (await this.client.post('/v1/embeddings', {
+                payload: {
+                    model,
+                    input: texts,
+                    encoding_format: 'float',
+                },
+            })) as EmbeddingResponse;
+            const ordered: { index: number; embedding: number[] }[] = [...r.data].sort((a, b) => a.index - b.index);
+            const promptTokens: number | undefined =
+                r.usage?.total_tokens ??
+                (r.usage ? (r.usage.prompt_tokens ?? 0) + (r.usage.completion_tokens ?? 0) : undefined);
+
+            return {
+                model,
+                results: ordered.map((entry) => ({
+                    outputs: [{ values: entry.embedding, modality: 'text' }],
+                })),
+                ...(typeof promptTokens === 'number'
+                    ? { usage: { input_tokens: promptTokens, input_text_tokens: promptTokens } }
+                    : {}),
+            };
+        } catch (error) {
+            if (LlumiverseError.isLlumiverseError(error)) throw error;
+            if (error instanceof Error && typeof (error as { status?: unknown }).status !== 'number') throw error;
+            throw this.formatLlumiverseError(error, {
+                provider: this.provider,
+                model,
+                operation: 'execute',
+            });
         }
     }
-
 }
 
 /**
@@ -214,4 +263,4 @@ function _makeChatCompletionRequest({
         response_format: responseFormat ?? undefined,
         stop: stopSequences ?? undefined,
     };
-};
+}

package/src/mistral/types.ts

@@ -112,6 +112,7 @@ export interface ChatCompletionResponseChunk {
 export interface Embedding {
     id: string;
     object: 'embedding';
+    index: number;
     embedding: number[];
 }
 
@@ -124,17 +125,17 @@ export interface EmbeddingResponse {
 }
 
 export interface CompletionRequestParams {
-    model: string,
-    messages: Array<{ role: string; name?: string, content: string | string[], tool_calls?: ToolCalls[]; }>,
-    tools?: Array<{ type: string; function: Function; }>,
-    temperature?: number,
-    maxTokens?: number,
-    topP?: number,
-    randomSeed?: number,
-    stream?: boolean,
-    toolChoice?: ToolChoice,
-    responseFormat?: ResponseFormat,
-    stopSequences?: string[],
+    model: string;
+    messages: Array<{ role: string; name?: string; content: string | string[]; tool_calls?: ToolCalls[] }>;
+    tools?: Array<{ type: string; function: Function }>;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    randomSeed?: number;
+    stream?: boolean;
+    toolChoice?: ToolChoice;
+    responseFormat?: ResponseFormat;
+    stopSequences?: string[];
 }
 
 // class MistralClient {
@@ -204,4 +205,4 @@ export interface CompletionRequestParams {
 //         model: string;
 //         input: string | string[];
 //     }): Promise<EmbeddingResponse>;
-// }
+// }

package/src/openai/azure_openai.ts

@@ -1,28 +1,31 @@
-import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
-import { AIModel, DriverOptions, getModelCapabilities, modelModalitiesToArray, Providers } from "@llumiverse/core";
-import OpenAI, { AzureOpenAI } from "openai";
-import { BaseOpenAIDriver } from "./index.js";
+import { DefaultAzureCredential, getBearerTokenProvider } from '@azure/identity';
+import {
+    type AIModel,
+    type DriverOptions,
+    getModelCapabilities,
+    modelModalitiesToArray,
+    Providers,
+} from '@llumiverse/core';
+import type OpenAI from 'openai';
+import { AzureOpenAI } from 'openai';
+import { BaseOpenAIDriver } from './index.js';
 
 export interface AzureOpenAIDriverOptions extends DriverOptions {
-
     /**
      * The credentials to use to access Azure OpenAI
      */
-    azureADTokenProvider?: any; //type with azure credentials
+    azureADTokenProvider?: (options?: unknown) => Promise<string>;
 
     apiKey?: string;
 
     endpoint?: string;
 
-    apiVersion?: string
+    apiVersion?: string;
 
     deployment?: string;
-
 }
 
 export class AzureOpenAIDriver extends BaseOpenAIDriver {
-
-
     service: AzureOpenAI;
     readonly provider = Providers.azure_openai;
 
@@ -43,8 +46,9 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
             apiKey: opts.apiKey,
             azureADTokenProvider: opts.azureADTokenProvider,
             endpoint: opts.endpoint,
-            apiVersion: opts.apiVersion ?? "2024-10-21",
-            deployment: opts.deployment
+            apiVersion: opts.apiVersion ?? '2024-10-21',
+            deployment: opts.deployment,
+            fetch: this.getDriverFetch(),
         });
     }
 
@@ -52,7 +56,7 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
      * Get default authentication for Azure Cognitive Services API
      */
     getDefaultCognitiveServicesAuth() {
-        const scope = "https://cognitiveservices.azure.com/.default";
+        const scope = 'https://cognitiveservices.azure.com/.default';
         const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
         return azureADTokenProvider;
     }
@@ -63,7 +67,9 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
 
     async _listModels(_filter?: (m: OpenAI.Models.Model) => boolean): Promise<AIModel[]> {
         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");
+            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.
@@ -71,22 +77,24 @@ export class AzureOpenAIDriver extends BaseOpenAIDriver {
         try {
             const testResponse = await this.service.chat.completions.create({
                 model: this.service.deploymentName,
-                messages: [{ role: "user", content: "Hi" }],
+                messages: [{ role: 'user', content: 'Hi' }],
                 max_tokens: 1,
             });
             modelID = testResponse.model;
         } catch (error) {
-            this.logger.error({ error }, "Failed to test model for Azure OpenAI listing :");
+            this.logger.error({ error }, 'Failed to test model for Azure OpenAI listing :');
         }
-        const modelCapability = getModelCapabilities(modelID, "openai");
-        return [{
-            id: modelID,
-            name: this.service.deploymentName,
-            provider: this.provider,
-            owner: "openai",
-            input_modalities: modelModalitiesToArray(modelCapability.input),
-            output_modalities: modelModalitiesToArray(modelCapability.output),
-            tool_support: modelCapability.tool_support,
-        } satisfies AIModel<string>];
+        const modelCapability = getModelCapabilities(modelID, 'openai');
+        return [
+            {
+                id: modelID,
+                name: this.service.deploymentName,
+                provider: this.provider,
+                owner: 'openai',
+                input_modalities: modelModalitiesToArray(modelCapability.input),
+                output_modalities: modelModalitiesToArray(modelCapability.output),
+                tool_support: modelCapability.tool_support,
+            } satisfies AIModel<string>,
+        ];
     }
-}
+}