openai-api-mock 0.1.7 → 0.1.8

package/main.test.js

@@ -1,7 +1,7 @@
 const { mockOpenAIResponse, stopMocking } = require('./main');
 
 const OpenAI = require('openai');
-const openai = new OpenAI({apiKey : "OPENAI_API_KEY"});
+const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });
 
 describe('Mock OpenAI Chat & Image generation API', () => {
     beforeEach(() => {
@@ -19,7 +19,6 @@ describe('Mock OpenAI Chat & Image generation API', () => {
                     { role: 'user', content: "Suggest at least 5 recipes" },
                 ]
             });
-
             expect(response.choices[0]).toHaveProperty('finish_reason', 'stop');
             expect(response.model).toEqual('gpt-3.5-mock');
         } catch (error) {
@@ -90,6 +89,67 @@ describe('Mock OpenAI Chat & Image generation API', () => {
     });
 
 
+    it('should mock the chat completion with function call (tools)', async () => {
+            const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'user', content: "Suggest at least 5 recipes" },
+                ],
+                tools: [
+                    {
+                    type: "function",
+                    function: {
+                        name: 'get_recipes',
+                        description: 'Suggest at least 5 recipes based on the ingredients you have',
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                recipes: {
+                                    type: "array",
+                                    description: "The recipes that can be made with the ingredients",
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            name: {
+                                                type: 'string',
+                                                description: 'The name of the recipe',
+                                            },
+                                            ingredients: {
+                                                type: 'array',
+                                                description: 'The ingredients needed for the recipe',
+                                                items: {
+                                                    type: 'string',
+                                                    description: 'The name of the ingredient',
+                                                },
+                                            },
+                                            instructions: {
+                                                type: 'string',
+                                                description: 'Detailed instructions on how to make the recipe',
+                                            },
+                                            serving: {
+                                                type: 'string',
+                                                description: 'The number of people the recipe serves',
+                                            },
+                                        }
+                                    }
+                                },
+                            }
+                        },
+                        required: ["recipes"],
+                    }
+
+                }],
+                tool_choice: { name: 'get_recipes' },
+            });
+            expect(response.model).toEqual('gpt-3.5-mock');
+            expect(response.choices[0]).toHaveProperty('finish_reason', 'tool_calls');
+            expect(response.choices[0].message.tool_calls[0].function).toHaveProperty('name', 'get_recipes');
+            expect(response.choices[0].message.tool_calls[0].function).toHaveProperty('arguments');
+            expect(JSON.parse(response.choices[0].message.tool_calls[0].function.arguments)).toHaveProperty('recipes');
+    });
+
+
     it('should mock image generation', async () => {
         try {
             const response = await openai.images.generate({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -11,7 +11,9 @@
     "mock",
     "api",
     "development",
-    "testing"
+    "testing",
+    "chatgpt",
+    "interceptor"
   ],
   "scripts": {
     "test": "jest"

package/readme.md

@@ -32,6 +32,42 @@ mockOpenAIResponse(force = true);
 The force parameter is a boolean that determines whether the mock response should be used regardless of the environment. 
 If force is true, the mock response will be used regardless of the environment. If force is false or not provided, the mock response will only be used if the <code>NODE_ENV</code> environment variable is set to 'development'.
 
+### Example responces
+
+```js
+// Call the mockOpenAIResponse function once to set up the mock
+mockOpenAIResponse() 
+
+// Now, when you call the OpenAI API, it will return a mock response
+const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'user', content: "Suggest at least 5 recipes" },
+                ]
+});
+ ```
+In this example, the `response` constant will contain mock data, simulating a response from the OpenAI API:
+
+```json
+{
+    choices: [
+        {
+          finish_reason: 'stop',
+          index: 0,
+          message: [Object],
+          logprobs: null
+        }
+      ],
+      created: 1707040459,
+      id: 'chatcmpl-tggOnwW8Lp2XiwQ8dmHHAcNYJ8CfzR',
+      model: 'gpt-3.5-mock',
+      object: 'chat.completion',
+      usage: { completion_tokens: 17, prompt_tokens: 57, total_tokens: 74 }
+}
+```
+
+
 ## Intercepted URLs
 
 This module uses the `nock` library to intercept HTTP calls to the following OpenAI API endpoints:

package/src/chat.js

@@ -3,7 +3,7 @@ const { faker } = require('@faker-js/faker');
 function getChatResponce(requestBody) {
     const created = Math.floor(Date.now() / 1000);
 
-    if (!requestBody.functions) {
+    if (!requestBody.functions && !requestBody.tools) {
         return createDefaultResponse(created);
     }
 
@@ -36,6 +36,10 @@ function createDefaultResponse(created) {
 }
 
 function createFunctionCallingResponse(requestBody, created) {
+    const isTool = Boolean(requestBody.tools);
+    const functionOrToolCallObject = isTool ? [createToolCallObject(requestBody)] : createFunctionCallObject(requestBody);
+    const functionOrToolCall = isTool ? 'tool_calls' : 'function_call';
+
     const functionCallingResponse = {
         id: `chatcmpl-${faker.string.alphanumeric(30)}`,
         object: 'chat.completion',
@@ -47,9 +51,9 @@ function createFunctionCallingResponse(requestBody, created) {
                 message: {
                     role: 'assistant',
                     content: null,
-                    function_call: createFunctionCallObject(requestBody),
+                    [functionOrToolCall]: functionOrToolCallObject,
                 },
-                finish_reason: 'function_call',
+                finish_reason: functionOrToolCall,
             },
         ],
         usage: {
@@ -62,6 +66,16 @@ function createFunctionCallingResponse(requestBody, created) {
     return functionCallingResponse;
 }
 
+function createToolCallObject(requestBody) {
+    return {
+        id: `call-${faker.string.alphanumeric(30)}`,
+        type: "function",
+        "function": {
+            name: `${requestBody.tools[0].function.name}`,
+            arguments: `${generateToolCallArguments(requestBody)}`
+        }
+    };
+}
 function createFunctionCallObject(requestBody) {
     return {
         name: `${requestBody.functions[0].name}`,
@@ -69,6 +83,17 @@ function createFunctionCallObject(requestBody) {
     };
 }
 
+function generateToolCallArguments(requestBody) {
+    const { parameters } = requestBody.tools[0].function;
+    const argumentsObject = {};
+
+    Object.entries(parameters.properties).forEach(([paramName, paramDetails]) => {
+        argumentsObject[paramName] = generateFakeData(paramDetails.type, paramDetails);
+    });
+
+    return JSON.stringify(argumentsObject, null, 2);
+}
+
 function generateFakeData(type, properties) {
     switch (type) {
         case 'string':