@crewdle/mist-connector-openai 1.0.12 → 1.0.14

package/dist/models/OpenAIFileConnector.js

@@ -22,6 +22,6 @@ export class OpenAIFileConnector {
         return uploadedFile.id;
     }
     async deleteFile(fileId) {
-        await this.client.files.del(fileId);
+        await this.client.files.delete(fileId);
     }
 }

package/dist/models/OpenAIGenerativeAIWorkerConnector.js

@@ -50,33 +50,43 @@ export class OpenAIGenerativeAIWorkerConnector {
         const responseFormat = this.getResponseFormat(parameters);
         const tools = this.getTools(parameters);
         const messages = this.getMessages(parameters);
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let accumulatedOutput = '';
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let output = '';
         while (true) {
-            const response = await this.client.chat.completions.create({
+            const response = await this.client.responses.create({
                 model: options.model.id,
-                messages,
-                max_completion_tokens: parameters.maxTokens,
+                input: messages,
+                max_output_tokens: parameters.maxTokens,
                 temperature: parameters.temperature,
-                response_format: responseFormat,
+                text: responseFormat,
                 tools,
             });
-            const message = response.choices[0].message;
-            totalInputTokens += response.usage?.prompt_tokens ?? 0;
-            totalOutputTokens += response.usage?.completion_tokens ?? 0;
-            if (!message.tool_calls) {
-                accumulatedOutput += message.content ?? '';
-                return {
-                    type: 'prompt',
-                    output: accumulatedOutput,
-                    inputTokens: totalInputTokens,
-                    outputTokens: totalOutputTokens,
-                };
-            }
+            inputTokens += response.usage?.input_tokens ?? 0;
+            outputTokens += response.usage?.output_tokens ?? 0;
             const promises = [];
-            this.processToolCalls(promises, message.tool_calls, messages, parameters.functions);
-            await Promise.all(promises);
+            for (const content of response.output) {
+                if (content.type === 'message') {
+                    for (const message of content.content) {
+                        if (message.type === 'output_text') {
+                            output += message.text;
+                        }
+                    }
+                }
+                if (content.type === 'function_call') {
+                    promises.push(this.processToolCall(parameters, messages, content.name, content.call_id, content.arguments));
+                }
+            }
+            if (promises.length > 0) {
+                await Promise.all(promises);
+                continue;
+            }
+            return {
+                type: "prompt" /* GenerativeAIJobType.Prompt */,
+                output,
+                inputTokens,
+                outputTokens,
+            };
         }
     }
     async *processJobStream(parameters, options) {
@@ -90,134 +100,96 @@ export class OpenAIGenerativeAIWorkerConnector {
         const tools = this.getTools(parameters);
         const messages = this.getMessages(parameters);
         while (true) {
-            const stream = await this.client.chat.completions.create({
+            const stream = await this.client.responses.create({
                 model: options.model.id,
-                messages,
-                max_completion_tokens: parameters.maxTokens,
+                input: messages,
+                max_output_tokens: parameters.maxTokens,
                 temperature: parameters.temperature,
-                stream: true,
-                stream_options: {
-                    include_usage: true,
-                },
+                text: responseFormat,
                 tools,
-                response_format: responseFormat,
+                stream: true,
             });
-            let message = {};
+            const promises = [];
             for await (const chunk of stream) {
-                if (chunk.choices[0]?.delta?.tool_calls) {
-                    message = this.messageReducer(message, chunk);
+                if (chunk.type === 'response.output_text.delta') {
+                    yield {
+                        type: "prompt" /* GenerativeAIJobType.Prompt */,
+                        output: chunk.delta,
+                        inputTokens: 0,
+                        outputTokens: 0,
+                    };
+                }
+                if (chunk.type === 'response.completed') {
+                    yield {
+                        type: "prompt" /* GenerativeAIJobType.Prompt */,
+                        output: '',
+                        inputTokens: chunk.response.usage?.input_tokens ?? 0,
+                        outputTokens: chunk.response.usage?.output_tokens ?? 0,
+                    };
                 }
+                if (chunk.type === 'response.output_item.done') {
+                    if (chunk.item.type === 'function_call') {
+                        promises.push(this.processToolCall(parameters, messages, chunk.item.name, chunk.item.call_id, chunk.item.arguments));
+                    }
+                }
+            }
+            if (promises.length > 0) {
+                await Promise.all(promises);
                 yield {
-                    type: 'prompt',
-                    output: chunk.choices[0]?.delta?.content ?? '',
-                    inputTokens: chunk.usage?.prompt_tokens ?? 0,
-                    outputTokens: chunk.usage?.completion_tokens ?? 0,
+                    type: "prompt" /* GenerativeAIJobType.Prompt */,
+                    output: '\n\n',
+                    inputTokens: 0,
+                    outputTokens: 0,
                 };
+                continue;
             }
-            if (!message.tool_calls) {
-                break;
-            }
-            const promises = [];
-            this.processToolCalls(promises, message.tool_calls, messages, parameters.functions);
-            await Promise.all(promises);
-            yield {
-                type: "prompt" /* GenerativeAIJobType.Prompt */,
-                output: '\n\n',
-                inputTokens: 0,
-                outputTokens: 0,
-            };
+            break;
         }
     }
-    processToolCalls(promises, toolCalls, messages, functions) {
+    async processToolCall(parameters, messages, toolName, toolCallId, input) {
         messages.push({
-            role: 'assistant',
-            content: null,
-            tool_calls: toolCalls,
-            refusal: null,
+            type: 'function_call',
+            arguments: input,
+            call_id: toolCallId,
+            name: toolName,
         });
-        for (const toolCall of toolCalls) {
-            if (toolCall?.function && functions) {
-                try {
-                    const func = functions.get(toolCall.function.name);
-                    if (func) {
-                        const result = func.callback(JSON.parse(toolCall.function.arguments));
-                        if (result instanceof Promise) {
-                            promises.push(result.then((res) => {
-                                messages.push({
-                                    role: 'tool',
-                                    tool_call_id: toolCall.id,
-                                    content: res ?? 'Tool does not exist',
-                                });
-                            }));
-                        }
-                        else {
-                            messages.push({
-                                role: 'tool',
-                                tool_call_id: toolCall.id,
-                                content: result ?? 'Tool does not exist',
-                            });
-                        }
-                    }
-                    else {
-                        messages.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            content: 'Tool does not exist',
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('Error processing tool call', error);
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: 'Error processing tool call',
-                    });
-                }
-            }
+        const func = parameters.functions?.get(toolName);
+        if (!func) {
+            messages.push({
+                type: 'function_call_output',
+                call_id: toolCallId,
+                output: 'Tool not found',
+            });
+            return;
         }
-    }
-    messageReducer(previous, item) {
-        const reduce = (acc, delta) => {
-            acc = { ...acc };
-            for (const [key, value] of Object.entries(delta)) {
-                if (acc[key] === undefined || acc[key] === null) {
-                    acc[key] = value;
-                    //  OpenAI.Chat.Completions.ChatCompletionMessageToolCall does not have a key, .index
-                    if (Array.isArray(acc[key])) {
-                        for (const arr of acc[key]) {
-                            delete arr.index;
-                        }
-                    }
-                }
-                else if (typeof acc[key] === 'string' && typeof value === 'string') {
-                    acc[key] += value;
-                }
-                else if (typeof acc[key] === 'number' && typeof value === 'number') {
-                    acc[key] = value;
-                }
-                else if (Array.isArray(acc[key]) && Array.isArray(value)) {
-                    const accArray = acc[key];
-                    for (let i = 0; i < value.length; i++) {
-                        const { index, ...chunkTool } = value[i];
-                        if (index - accArray.length > 1) {
-                            throw new Error(`Error: An array has an empty value when tool_calls are constructed. tool_calls: ${accArray}; tool: ${value}`);
-                        }
-                        accArray[index] = reduce(accArray[index], chunkTool);
-                    }
-                }
-                else if (typeof acc[key] === 'object' && typeof value === 'object') {
-                    acc[key] = reduce(acc[key], value);
-                }
+        try {
+            if (input === '') {
+                input = '{}';
+            }
+            const result = func.callback(JSON.parse(input));
+            if (result instanceof Promise) {
+                messages.push({
+                    type: 'function_call_output',
+                    call_id: toolCallId,
+                    output: await result,
+                });
+            }
+            else {
+                messages.push({
+                    type: 'function_call_output',
+                    call_id: toolCallId,
+                    output: result,
+                });
             }
-            return acc;
-        };
-        const choice = item.choices[0];
-        if (!choice) {
-            // chunk contains information about usage and token counts
-            return previous;
         }
-        return reduce(previous, choice.delta);
+        catch (error) {
+            console.error('Error processing tool call', error);
+            messages.push({
+                type: 'function_call_output',
+                call_id: toolCallId,
+                output: 'Error processing tool call',
+            });
+        }
     }
     getMessages(parameters) {
         const messages = [];
@@ -237,31 +209,58 @@ export class OpenAIGenerativeAIWorkerConnector {
         }
         messages.push({
             role: 'user',
-            content: parameters.prompt,
+            content: this.getInnerMessages(parameters.prompt),
         });
         return messages;
     }
+    getInnerMessages(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return content.map((c) => {
+            if (c.type === 'text') {
+                return {
+                    type: 'input_text',
+                    text: c.text,
+                };
+            }
+            if (c.type === 'file') {
+                return {
+                    type: 'input_file',
+                    filename: c.file.filename,
+                    file_data: c.file.file_data,
+                };
+            }
+            if (c.type === 'image_url') {
+                return {
+                    type: 'input_image',
+                    image_url: c.image_url.url,
+                };
+            }
+            throw new Error('Invalid content type');
+        });
+    }
     getTools(parameters) {
         if (!parameters.functions || parameters.functions.size === 0) {
             return undefined;
         }
         const tools = [];
         for (const [name, func] of parameters.functions) {
-            let params;
+            let params = null;
             if (func.params) {
                 params = {
                     type: 'object',
                     properties: func.params,
                     required: Object.keys(func.params),
+                    additionalProperties: false,
                 };
             }
             tools.push({
                 type: 'function',
-                function: {
-                    name,
-                    description: func.description,
-                    parameters: params,
-                }
+                name,
+                description: func.description,
+                strict: true,
+                parameters: params,
             });
         }
         return tools;
@@ -271,33 +270,38 @@ export class OpenAIGenerativeAIWorkerConnector {
             return undefined;
         }
         if (parameters.grammar === 'json') {
-            return { type: 'json_object' };
+            return { format: { type: 'json_object' } };
         }
         if (parameters.grammar === 'if_else') {
             return {
-                type: 'json_schema',
-                json_schema: {
+                format: {
+                    type: 'json_schema',
+                    strict: true,
                     name: 'router_response',
                     schema: {
                         type: 'object',
                         properties: {
-                            'condition_result': {
+                            condition_result: {
                                 type: 'boolean',
+                                description: 'Indicates whether a certain condition is met.'
                             }
                         },
-                        required: ['result'],
-                        additionalProperties: false,
-                    }
+                        required: [
+                            'condition_result'
+                        ],
+                        additionalProperties: false
+                    },
                 }
             };
         }
         if (parameters.grammar !== 'default') {
             return {
-                type: 'json_schema',
-                json_schema: {
+                format: {
+                    type: 'json_schema',
+                    strict: true,
                     name: 'custom_response',
                     schema: parameters.grammar,
-                }
+                },
             };
         }
         return undefined;

package/dist/models/OpenAISpeechConnector.js

@@ -14,7 +14,20 @@ export class OpenAISpeechConnector {
             instructions,
             response_format: 'pcm',
         });
-        return response.arrayBuffer();
+        if (!response.body) {
+            throw new Error('No response body');
+        }
+        if (response.body instanceof ReadableStream) {
+            return response.body;
+        }
+        const audio = response.body;
+        return new ReadableStream({
+            start(controller) {
+                audio.on('data', (chunk) => controller.enqueue(chunk));
+                audio.on('end', () => controller.close());
+                audio.on('error', (err) => controller.error(err));
+            }
+        });
     }
     getEngineType() {
         return 'openai';

package/dist/types/models/OpenAIGenerativeAIWorkerConnector.d.ts

@@ -9,9 +9,9 @@ export declare class OpenAIGenerativeAIWorkerConnector implements IGenerativeAIW
     getEngineType(): GenerativeAIEngineType;
     processJob(parameters: GenerativeAIWorkerConnectorParameters, options?: IGenerativeAIWorkerOptions): Promise<IGenerativeAIWorkerConnectorPromptResult>;
     processJobStream(parameters: GenerativeAIWorkerConnectorParameters, options?: IGenerativeAIWorkerOptions): AsyncGenerator<IGenerativeAIWorkerConnectorPromptResult>;
-    private processToolCalls;
-    private messageReducer;
+    private processToolCall;
     private getMessages;
+    private getInnerMessages;
     private getTools;
     private getResponseFormat;
 }

package/dist/types/models/OpenAISpeechConnector.d.ts

@@ -2,6 +2,6 @@ import { GenerativeAIEngineType, IGenerativeAISpeechConnector } from '@crewdle/w
 export declare class OpenAISpeechConnector implements IGenerativeAISpeechConnector {
     private client;
     constructor(apiKey: string);
-    speak(model: string, text: string, voice: string, instructions?: string): Promise<ArrayBuffer>;
+    speak(model: string, text: string, voice: string, instructions?: string): Promise<ReadableStream>;
     getEngineType(): GenerativeAIEngineType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewdle/mist-connector-openai",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
@@ -15,11 +15,11 @@
     "dist/"
   ],
   "devDependencies": {
-    "@crewdle/web-sdk-types": "^1.0.44",
+    "@crewdle/web-sdk-types": "^1.0.46",
     "@types/node": "^22.13.9",
     "typescript": "^5.8.2"
   },
   "dependencies": {
-    "openai": "^4.100.0"
+    "openai": "^5.5.1"
   }
 }