@llumiverse/drivers 0.13.0 → 0.14.0

package/src/bedrock/index.ts

@@ -6,6 +6,7 @@ import { transformAsyncIterator } from "@llumiverse/core/async";
 import { ClaudeMessagesPrompt, formatClaudePrompt } from "@llumiverse/core/formatters";
 import { AwsCredentialIdentity, Provider } from "@smithy/types";
 import mnemonist from "mnemonist";
+import { AI21RequestPayload, AmazonRequestPayload, ClaudeRequestPayload, CohereCommandRPayload, CohereRequestPayload, LLama2RequestPayload, MistralPayload } from "./payloads.js";
 import { forceUploadFile } from "./s3.js";
 
 const { LRUCache } = mnemonist;
@@ -23,7 +24,7 @@ export interface BedrockDriverOptions extends DriverOptions {
      */
     region: string;
     /**
-     * Tthe bucket name to be used for training. 
+     * Tthe bucket name to be used for training.
      * It will be created oif nto already exixts
      */
     training_bucket?: string;
@@ -62,7 +63,7 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
             this._executor = new BedrockRuntime({
                 region: this.options.region,
                 credentials: this.options.credentials,
-                
+
             });
         }
         return this._executor;
@@ -78,14 +79,13 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
         return this._service;
     }
 
-    protected formatPrompt(segments: PromptSegment[], opts: PromptOptions): BedrockPrompt {
+    protected async formatPrompt(segments: PromptSegment[], opts: PromptOptions): Promise<BedrockPrompt> {
         //TODO move the anthropic test in abstract driver?
         if (opts.model.includes('anthropic')) {
             //TODO: need to type better the types aren't checked properly by TS
-            const prompt = formatClaudePrompt(segments, opts.resultSchema);
-            return prompt;
+            return await formatClaudePrompt(segments, opts.result_schema);
         } else {
-            return super.formatPrompt(segments, opts) as string;
+            return await super.formatPrompt(segments, opts) as string;
         }
     }
 
@@ -100,20 +100,23 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                 // LLAMA2
                 return [result.generation, result.stop_reason]; // comes in coirrect format (stop, length)
             } else if (result.generations) {
-                // COHERE                
+                // Cohere
                 return [result.generations[0].text, cohereFinishReason(result.generations[0].finish_reason)];
+            } else if (result.chat_history) {
+                //Cohere Command R
+                return [result.text, cohereFinishReason(result.finish_reason)];
             } else if (result.completions) {
                 //A21
                 return [result.completions[0].data?.text, a21FinishReason(result.completions[0].finishReason?.reason)];
             } else if (result.content) {
-                // anthropic claude 
+                // Claude
                 //if last prompt.messages is {, add { to the response
-                const p =  prompt as ClaudeMessagesPrompt;
+                const p = prompt as ClaudeMessagesPrompt;
                 const lastMessage = (p as ClaudeMessagesPrompt).messages[p.messages.length - 1];
                 const res = lastMessage.content[0].text === '{' ? '{' + result.content[0]?.text : result.content[0]?.text;
 
-                return [ res, claudeFinishReason(result.stop_reason)];
-                
+                return [res, claudeFinishReason(result.stop_reason)];
+
             } else if (result.outputs) {
                 // mistral
                 return [result.outputs[0]?.text, result.outputs[0]?.stop_reason]; // the stop reason is in the expected format ("stop" and "length")
@@ -146,7 +149,6 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
 
         const payload = this.preparePayload(prompt, options);
         const executor = this.getExecutor();
-        console.log("Requesting completion", JSON.stringify(payload));
         const res = await executor.invokeModel({
             modelId: options.model,
             contentType: "application/json",
@@ -171,10 +173,9 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
         return canStream;
     }
 
-    async requestCompletionStream(prompt: string, options: ExecutionOptions): Promise<AsyncIterable<string>> {
+    async requestCompletionStream(prompt: BedrockPrompt, options: ExecutionOptions): Promise<AsyncIterable<string>> {
         const payload = this.preparePayload(prompt, options);
         const executor = this.getExecutor();
-        console.log("Requesting completion stream", JSON.stringify(payload));
         return executor.invokeModelWithResponseStream({
             modelId: options.model,
             contentType: "application/json",
@@ -186,12 +187,24 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
             }
             const decoder = new TextDecoder();
 
+            const addBracket = () => {
+                if (typeof prompt === 'object' && (prompt as ClaudeMessagesPrompt).messages) {
+                    const p = prompt as ClaudeMessagesPrompt;
+                    const lastMessage = p.messages[p.messages.length - 1];
+                    return lastMessage.content[0].text === '{';
+                }
+                return false;
+            };
+
             return transformAsyncIterator(res.body, (stream: ResponseStream) => {
                 const segment = JSON.parse(decoder.decode(stream.chunk?.bytes));
+                //console.log("Debug Segment for model " + options.model, JSON.stringify(segment));
                 if (segment.delta) { // who is this?
                     return segment.delta.text || '';
                 } else if (segment.completion) { // who is this?
                     return segment.completion;
+                } else if (segment.text) { //cohere
+                    return segment.text;
                 } else if (segment.completions) {
                     return segment.completions[0].data?.text;
                 } else if (segment.generation) {
@@ -211,7 +224,9 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                     segment.toString();
                 }
 
-            });
+            },
+                () => addBracket() ? '{' : ''
+            );
 
         }).catch((err) => {
             this.logger.error("[Bedrock] Failed to stream", err);
@@ -235,11 +250,22 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                 max_gen_len: options.max_tokens,
             } as LLama2RequestPayload
         } else if (contains(options.model, "claude")) {
+
+            const maxToken = () => {
+                if (options.max_tokens) {
+                    return options.max_tokens;
+                
+                } else if (contains(options.model, "claude-3-5")) {
+                    return 8192;
+                } else {
+                    return 4096
+                }
+            }
             return {
                 anthropic_version: "bedrock-2023-05-31",
                 ...(prompt as ClaudeMessagesPrompt),
                 temperature: options.temperature,
-                max_tokens: options.max_tokens,
+                max_tokens: maxToken(),
             } as ClaudeRequestPayload;
         } else if (contains(options.model, "ai21")) {
             return {
@@ -247,12 +273,19 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                 temperature: options.temperature,
                 maxTokens: options.max_tokens,
             } as AI21RequestPayload;
-        } else if (contains(options.model, "cohere")) {
+        } else if (contains(options.model, "command-r-plus")) {
+            return {
+                message: prompt as string,
+                max_tokens: options.max_tokens,
+                temperature: options.temperature,
+            } as CohereCommandRPayload;
+
+        }
+        else if (contains(options.model, "cohere")) {
             return {
                 prompt: prompt,
                 temperature: options.temperature,
                 max_tokens: options.max_tokens,
-                p: 0.9,
             } as CohereRequestPayload;
         } else if (contains(options.model, "amazon")) {
             return {
@@ -289,7 +322,8 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
         }
 
         const s3 = new S3Client({ region: this.options.region, credentials: this.options.credentials });
-        const upload = await forceUploadFile(s3, dataset.getStream(), this.options.training_bucket, dataset.name);
+        const stream = await dataset.getStream();
+        const upload = await forceUploadFile(s3, stream, this.options.training_bucket, dataset.name);
 
         const service = this.getService();
         const response = await service.send(new CreateModelCustomizationJobCommand({
@@ -363,10 +397,11 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
             service.listFoundationModels({}).catch(() => {
                 this.logger.warn("[Bedrock] Can't list foundation models. Check if the user has the right permissions.");
                 return undefined
-                }),
+            }),
             service.listCustomModels({}).catch(() => {
                 this.logger.warn("[Bedrock] Can't list custom models. Check if the user has the right permissions.");
-                return undefined}),
+                return undefined
+            }),
         ]);
 
         if (!foundationals?.modelSummaries) {
@@ -390,7 +425,8 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                 provider: this.provider,
                 //description: ``,
                 owner: m.providerName,
-                canStream: m.responseStreamingSupported ?? false,
+                can_stream: m.responseStreamingSupported ?? false,
+                is_multimodal: m.inputModalities?.includes("IMAGE") ?? false,
                 tags: m.outputModalities ?? [],
             };
 
@@ -410,7 +446,7 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
                     name: m.modelName ?? m.modelArn,
                     provider: this.provider,
                     description: `Custom model from ${m.baseModelName}`,
-                    isCustom: true,
+                    is_custom: true,
                 };
 
                 aimodels.push(model);
@@ -459,55 +495,6 @@ export class BedrockDriver extends AbstractDriver<BedrockDriverOptions, BedrockP
 
 
 
-interface LLama2RequestPayload {
-    prompt: string;
-    temperature: number;
-    top_p?: number;
-    max_gen_len: number;
-}
-
-interface ClaudeRequestPayload extends ClaudeMessagesPrompt {
-    anthropic_version: "bedrock-2023-05-31",
-    max_tokens: number,
-    prompt: string;
-    temperature?: number;
-    top_p?: number,
-    top_k?: number,
-    stop_sequences?: [string];
-}
-
-interface AI21RequestPayload {
-    prompt: string;
-    temperature: number;
-    maxTokens: number;
-}
-
-interface CohereRequestPayload {
-    prompt: string;
-    temperature: number;
-    max_tokens?: number;
-    p?: number;
-}
-
-interface AmazonRequestPayload {
-    inputText: string,
-    textGenerationConfig: {
-        temperature: number,
-        topP: number,
-        maxTokenCount: number,
-        stopSequences: [string];
-    };
-}
-
-interface MistralPayload {
-    prompt: string,
-    temperature: number,
-    max_tokens: number,
-    top_p?: number,
-    top_k?: number,
-}
-
-
 function jobInfo(job: GetModelCustomizationJobCommandOutput, jobId: string): TrainingJob {
     const jobStatus = job.status;
     let status = TrainingJobStatus.running;

package/src/bedrock/payloads.ts

@@ -0,0 +1,67 @@
+import { ClaudeMessagesPrompt } from "@llumiverse/core/formatters";
+
+export interface LLama2RequestPayload {
+    prompt: string;
+    temperature: number;
+    top_p?: number;
+    max_gen_len: number;
+}
+export interface ClaudeRequestPayload extends ClaudeMessagesPrompt {
+    anthropic_version: "bedrock-2023-05-31";
+    max_tokens: number;
+    prompt: string;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: [string];
+}
+export interface AI21RequestPayload {
+    prompt: string;
+    temperature: number;
+    maxTokens: number;
+}
+export interface CohereRequestPayload {
+    prompt: string;
+    temperature: number;
+    max_tokens?: number;
+    p?: number;
+}
+export interface AmazonRequestPayload {
+    inputText: string;
+    textGenerationConfig: {
+        temperature: number;
+        topP: number;
+        maxTokenCount: number;
+        stopSequences: [string];
+    };
+}
+export interface MistralPayload {
+    prompt: string;
+    temperature: number;
+    max_tokens: number;
+    top_p?: number;
+    top_k?: number;
+}
+
+export interface CohereCommandRPayload {
+
+    message: string,
+    chat_history?: {
+        role: 'USER' | 'CHATBOT',
+        message: string }[],
+    documents?: { title: string, snippet: string }[],
+    search_queries_only?: boolean,
+    preamble?: string,
+    max_tokens: number,
+    temperature?: number,
+    p?: number,
+    k?: number,
+    prompt_truncation?: string,
+    frequency_penalty?: number,
+    presence_penalty?: number,
+    seed?: number,
+    return_prompt?: boolean,
+    stop_sequences?: string[],
+    raw_prompting?: boolean
+
+}

package/src/groq/index.ts

@@ -1,6 +1,6 @@
 import { AIModel, AbstractDriver, Completion, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment } from "@llumiverse/core";
 import { transformAsyncIterator } from "@llumiverse/core/async";
-import { OpenAITextMessage, formatOpenAILikePrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
+import { OpenAITextMessage, formatOpenAILikeTextPrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
 import Groq from "groq-sdk";
 
 
@@ -27,7 +27,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, OpenAITextMess
     }
 
     // protected canStream(options: ExecutionOptions): Promise<boolean> {
-    //     if (options.resultSchema) {
+    //     if (options.result_schema) {
     //         // not yet streamign json responses
     //         return Promise.resolve(false);
     //     } else {
@@ -42,17 +42,17 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, OpenAITextMess
         //     type: "json_object",
         // }
 
-        // return _options.resultSchema ? responseFormatJson : undefined;
+        // return _options.result_schema ? responseFormatJson : undefined;
         return undefined;
     }
 
-    protected formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): OpenAITextMessage[] {
-        const messages = formatOpenAILikePrompt(segments);
+    protected async formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<OpenAITextMessage[]> {
+        const messages = formatOpenAILikeTextPrompt(segments);
         //Add JSON instruction is schema is provided
-        if (opts.resultSchema) {
+        if (opts.result_schema) {
             messages.push({
                 role: "user",
-                content: "IMPORTANT: " + getJSONSafetyNotice(opts.resultSchema)
+                content: "IMPORTANT: " + getJSONSafetyNotice(opts.result_schema)
             });
         }
         return messages;

package/src/index.ts

@@ -2,9 +2,11 @@ export * from "./bedrock/index.js";
 export * from "./groq/index.js";
 export * from "./huggingface_ie.js";
 export * from "./mistral/index.js";
-export * from "./openai.js";
+export * from "./openai/azure.js";
+export * from "./openai/openai.js";
 export * from "./replicate.js";
 export * from "./test/index.js";
 export * from "./togetherai/index.js";
 export * from "./vertexai/index.js";
 export * from "./watsonx/index.js";
+

package/src/mistral/index.ts

@@ -1,6 +1,6 @@
 import { AIModel, AbstractDriver, Completion, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment } from "@llumiverse/core";
 import { transformSSEStream } from "@llumiverse/core/async";
-import { OpenAITextMessage, formatOpenAILikePrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
+import { OpenAITextMessage, formatOpenAILikeTextPrompt, getJSONSafetyNotice } from "@llumiverse/core/formatters";
 import { FetchClient } from "api-fetch-client";
 import { ChatCompletionResponse, CompletionRequestParams, ListModelsResponse, ResponseFormat } from "./types.js";
 
@@ -42,20 +42,20 @@ export class MistralAIDriver extends AbstractDriver<MistralAIDriverOptions, Open
         // } as ResponseFormat;
 
 
-        // return _options.resultSchema ? responseFormatJson : responseFormatText;
+        // 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 mistrall tiny or medium are throwing an error when using the response_format parameter
         return undefined
     }
 
-    protected formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): OpenAITextMessage[] {
-        const messages = formatOpenAILikePrompt(segments);
+    protected async formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<OpenAITextMessage[]> {
+        const messages = formatOpenAILikeTextPrompt(segments);
         //Add JSON instruction is schema is provided
-        if (opts.resultSchema) {
+        if (opts.result_schema) {
             messages.push({
                 role: "user",
-                content: "IMPORTANT: " + getJSONSafetyNotice(opts.resultSchema)
+                content: "IMPORTANT: " + getJSONSafetyNotice(opts.result_schema)
             });
         }
         return messages;

package/src/openai/azure.ts

@@ -0,0 +1,54 @@
+import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
+import { DriverOptions } from "@llumiverse/core";
+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 credntials
+    
+    apiKey?: string;
+
+    endpoint?: string;
+
+    apiVersion?: string
+
+    deployment?: string;
+
+}
+
+export class AzureOpenAIDriver extends BaseOpenAIDriver {
+
+
+    service: AzureOpenAI;
+    provider: "azure_openai";
+
+    constructor(opts: AzureOpenAIDriverOptions) {
+        super(opts);
+
+        if (!opts.azureADTokenProvider && !opts.apiKey) {
+            opts.azureADTokenProvider = this.getDefaultAuth();
+        }
+
+        this.service = new AzureOpenAI({
+            apiKey: opts.apiKey,
+            azureADTokenProvider: opts.azureADTokenProvider,          
+            endpoint: opts.endpoint,
+            apiVersion: opts.apiVersion ?? "2024-05-01-preview",
+            deployment: opts.deployment
+        });
+        this.provider = "azure_openai";
+    }
+
+
+    getDefaultAuth() {
+        const scope = "https://cognitiveservices.azure.com/.default";
+        const azureADTokenProvider = getBearerTokenProvider(new DefaultAzureCredential(), scope);
+        return azureADTokenProvider;
+    }      
+
+
+}

package/src/{openai.ts → openai/index.ts}

@@ -15,8 +15,8 @@ import {
     TrainingPromptOptions
 } from "@llumiverse/core";
 import { asyncMap } from "@llumiverse/core/async";
-import { formatOpenAILikePrompt } from "@llumiverse/core/formatters";
-import OpenAI from "openai";
+import { formatOpenAILikeMultimodalPrompt } from "@llumiverse/core/formatters";
+import OpenAI, { AzureOpenAI } from "openai";
 import { Stream } from "openai/streaming";
 
 const supportFineTunning = new Set([
@@ -27,26 +27,20 @@ const supportFineTunning = new Set([
     "gpt-4-0613"
 ]);
 
-export interface OpenAIDriverOptions extends DriverOptions {
-    apiKey: string;
+export interface BaseOpenAIDriverOptions extends DriverOptions {
 }
 
-export class OpenAIDriver extends AbstractDriver<
-    OpenAIDriverOptions,
+export abstract class BaseOpenAIDriver extends AbstractDriver<
+    BaseOpenAIDriverOptions,
     OpenAI.Chat.Completions.ChatCompletionMessageParam[]
 > {
-    static PROVIDER = "openai";
-    inputContentTypes: string[] = ["text/plain"];
-    generatedContentTypes: string[] = ["text/plain"];
-    service: OpenAI;
-    provider = OpenAIDriver.PROVIDER;
+    abstract provider: "azure_openai" | "openai";
+    abstract service: OpenAI | AzureOpenAI ;
 
-    constructor(opts: OpenAIDriverOptions) {
+    constructor(opts: BaseOpenAIDriverOptions) {
         super(opts);
-        this.service = new OpenAI({
-            apiKey: opts.apiKey,
-        });
-        this.formatPrompt = formatOpenAILikePrompt;
+        this.formatPrompt = formatOpenAILikeMultimodalPrompt as any //TODO: better type, we send back OpenAI.Chat.Completions.ChatCompletionMessageParam[] but just not compatbile with Function call that we don't use here
+
     }
 
     extractDataFromResponse(
@@ -63,7 +57,7 @@ export class OpenAIDriver extends AbstractDriver<
         const finish_reason = choice.finish_reason;
 
         //if no schema, return content
-        if (!options.resultSchema) {
+        if (!options.result_schema) {
             return {
                 result: choice.message.content as string,
                 token_usage: tokenInfo,
@@ -86,7 +80,7 @@ export class OpenAIDriver extends AbstractDriver<
     }
 
     async requestCompletionStream(prompt: OpenAI.Chat.Completions.ChatCompletionMessageParam[], options: ExecutionOptions): Promise<any> {
-        const mapFn = options.resultSchema
+        const mapFn = options.result_schema
             ? (chunk: OpenAI.Chat.Completions.ChatCompletionChunk) => {
                 return (
                     chunk.choices[0]?.delta?.tool_calls?.[0].function?.arguments ?? ""
@@ -103,18 +97,18 @@ export class OpenAIDriver extends AbstractDriver<
             temperature: options.temperature,
             n: 1,
             max_tokens: options.max_tokens,
-            tools: options.resultSchema
+            tools: options.result_schema
                 ? [
                     {
                         function: {
                             name: "format_output",
-                            parameters: options.resultSchema as any,
+                            parameters: options.result_schema as any,
                         },
                         type: "function"
                     } as OpenAI.Chat.ChatCompletionTool,
                 ]
                 : undefined,
-            tool_choice: options.resultSchema
+            tool_choice: options.result_schema
                 ? {
                     type: 'function',
                     function: { name: "format_output" }
@@ -125,12 +119,12 @@ export class OpenAIDriver extends AbstractDriver<
     }
 
     async requestCompletion(prompt: OpenAI.Chat.Completions.ChatCompletionMessageParam[], options: ExecutionOptions): Promise<any> {
-        const functions = options.resultSchema
+        const functions = options.result_schema
             ? [
                 {
                     function: {
                         name: "format_output",
-                        parameters: options.resultSchema as any,
+                        parameters: options.result_schema as any,
                     },
                     type: 'function'
                 } as OpenAI.Chat.ChatCompletionTool,
@@ -145,13 +139,13 @@ export class OpenAIDriver extends AbstractDriver<
             n: 1,
             max_tokens: options.max_tokens,
             tools: functions,
-            tool_choice: options.resultSchema
+            tool_choice: options.result_schema
                 ? {
                     type: 'function',
                     function: { name: "format_output" }
                 } : undefined,
             // functions: functions,
-            // function_call: options.resultSchema
+            // function_call: options.result_schema
             //     ? { name: "format_output" }
             //     : undefined,
         });
@@ -163,11 +157,11 @@ export class OpenAIDriver extends AbstractDriver<
         return completion;
     }
 
-    createTrainingPrompt(options: TrainingPromptOptions): string {
+    createTrainingPrompt(options: TrainingPromptOptions): Promise<string> {
         if (options.model.includes("gpt")) {
             return super.createTrainingPrompt(options);
         } else {
-            // babbage, davinci not yet implemented 
+            // babbage, davinci not yet implemented
             throw new Error("Unsupported model for training: " + options.model);
         }
     }
@@ -217,7 +211,7 @@ export class OpenAIDriver extends AbstractDriver<
         return this._listModels();
     }
 
-    async _listModels(filter?: (m: OpenAI.Models.Model) => boolean) {
+    async _listModels(filter?: (m: OpenAI.Models.Model) => boolean): Promise<AIModel[]> {
         let result = await this.service.models.list();
         const models = filter ? result.data.filter(filter) : result.data;
         return models.map((m) => ({
@@ -226,6 +220,8 @@ export class OpenAIDriver extends AbstractDriver<
             provider: this.provider,
             owner: m.owned_by,
             type: m.object === "model" ? ModelType.Text : ModelType.Unknown,
+            can_stream: true,
+            is_multimodal: m.id.includes("gpt-4")
         }));
     }
 

package/src/openai/openai.ts

@@ -0,0 +1,33 @@
+
+
+import { DriverOptions } from "@llumiverse/core";
+import OpenAI from "openai";
+import { BaseOpenAIDriver } from "./index.js";
+
+export interface OpenAIDriverOptions extends DriverOptions {
+
+    /**
+     * The OpenAI api key
+     */
+    apiKey?: string; //type with azure credntials
+    
+}
+
+
+
+
+export class OpenAIDriver extends BaseOpenAIDriver {
+
+    service: OpenAI;
+    provider: "openai";
+
+    constructor(opts: OpenAIDriverOptions) {
+        super(opts);
+        this.service = new OpenAI({
+            apiKey: opts.apiKey
+        });
+        this.provider = "openai";
+    }
+
+
+}