openai mapping tests and bug fixes

Author: anthonyjgrove

src/__tests__/__snapshots__/Client.test.ts.snap

@@ -24,8 +24,8 @@ exports[`client getOpenAiPrompt returnsmapped prompt 1`] = `
   },
   "seed": null,
   "temperature": 0.7,
-  "tool_choice": "auto",
-  "tools": [],
+  "tool_choice": "none",
+  "tools": undefined,
   "top_p": 1,
 }
 `;

src/helpers/__tests__/openAi.test.ts

@@ -0,0 +1,113 @@
+import { createPromptConfigurationFixture } from '../../../test/__fixtures__/promptConfiguration'
+import { createPromptMessageFixture } from '../../../test/__fixtures__/promptMessage'
+import { createPromptToolFixture } from '../../../test/__fixtures__/promptTool'
+import { PromptMessageRoleEnum, PromptTool } from '../../types'
+import { mapMessagesToOpenAI, mapPromptToOpenAIConfig, mapToolChoiceToOpenAI } from '../openAi'
+
+describe('openAi helpers', () => {
+  describe('mapMessagesToOpenAI', () => {
+    const mockMessages = [
+      createPromptMessageFixture({ role: PromptMessageRoleEnum.TOOL, content: 'content1', toolCallId: 'id1' }),
+      createPromptMessageFixture({ role: PromptMessageRoleEnum.ASSISTANT, content: 'content2' }),
+      createPromptMessageFixture({ role: PromptMessageRoleEnum.USER, content: 'content3' }),
+      createPromptMessageFixture({ role: PromptMessageRoleEnum.SYSTEM, content: 'content4' })
+    ]
+
+    it('should correctly map tool messages', () => {
+      const result = mapMessagesToOpenAI([mockMessages[0]])
+      expect(result[0]).toEqual({
+        role: 'tool',
+        content: 'content1',
+        tool_call_id: 'id1'
+      })
+    })
+
+    it('should correctly map assistant messages', () => {
+      const result = mapMessagesToOpenAI([mockMessages[1]])
+      expect(result[0]).toEqual({
+        role: 'assistant',
+        content: 'content2',
+        name: undefined,
+        tool_calls: undefined
+      })
+    })
+
+    it('should correctly map user messages', () => {
+      const result = mapMessagesToOpenAI([mockMessages[2]])
+      expect(result[0]).toEqual({
+        role: 'user',
+        name: undefined,
+        content: 'content3'
+      })
+    })
+
+    it('should correctly map system messages', () => {
+      const result = mapMessagesToOpenAI([mockMessages[3]])
+      expect(result[0]).toEqual({
+        role: 'system',
+        content: 'content4'
+      })
+    })
+
+    it('should throw an error for invalid message roles', () => {
+      expect(() => mapMessagesToOpenAI([createPromptMessageFixture({ role: 'invalid', content: 'content5' } as any)])).toThrow(
+        'Invalid message role: invalid'
+      )
+    })
+
+    // Additional test cases for missing fields and other edge cases can be added here.
+  })
+
+  describe('mapPromptToOpenAIConfig', () => {
+    const mockPromptConfig = createPromptConfigurationFixture()
+
+    it('should map the configuration to OpenAI parameters correctly', () => {
+      const result = mapPromptToOpenAIConfig(mockPromptConfig)
+      expect(result).toEqual({
+        messages: [{ role: 'user', name: undefined, content: 'Hello world' }],
+        model: 'text-davinci-002',
+        top_p: 0.5,
+        max_tokens: 150,
+        temperature: 0.7,
+        seed: 42,
+        presence_penalty: 0.1,
+        frequency_penalty: 0.1,
+        tool_choice: 'none',
+        response_format: {
+          type: 'json_object'
+        },
+        tools: undefined
+      })
+    })
+
+    // Additional test cases to test other configurations and scenarios can be added here.
+  })
+
+  describe('mapToolChoiceToOpenAI', () => {
+    it('should return "auto" if toolChoice is "auto" or there are tools available and toolChoice is undefined', () => {
+      const tools = [createPromptToolFixture()]
+      expect(mapToolChoiceToOpenAI(tools, 'auto')).toBe('auto')
+      expect(mapToolChoiceToOpenAI(tools)).toBe('auto')
+    })
+
+    it('should return "none" if there are no tools or toolChoice is "none"', () => {
+      const tools: PromptTool[] = []
+      expect(mapToolChoiceToOpenAI(tools, 'none')).toBe('none')
+      expect(mapToolChoiceToOpenAI(tools)).toBe('none')
+      expect(mapToolChoiceToOpenAI(tools, 'auto')).toBe('none')
+    })
+
+    it('should return tool function object if a valid toolChoice matches a tool', () => {
+      const tools = [createPromptToolFixture({ name: 'exampleTool' })]
+      expect(mapToolChoiceToOpenAI(tools, 'exampleTool')).toEqual({
+        type: 'function',
+        function: { name: 'exampleTool' }
+      })
+    })
+
+    it('should return "none" if the toolChoice does not match any tool', () => {
+      const tools = [createPromptToolFixture({ name: 'exampleTool' })]
+      expect(mapToolChoiceToOpenAI(tools, 'nonexistentTool')).toBe('none')
+    })
+  })
+})

src/helpers/openAi.ts

@@ -69,11 +69,14 @@ export const mapMessagesToOpenAI = (promptMessages: PromptMessage[]): ChatComple
   })
 }
 
-const mapToolChoiceToOpenAI = (tools: PromptTool[], toolChoice?: string | null): ChatCompletionToolChoiceOption => {
+export const mapToolChoiceToOpenAI = (tools: PromptTool[], toolChoice?: string | null): ChatCompletionToolChoiceOption => {
+  if (tools.length === 0) {
+    return 'none'
+  }
   if (toolChoice === 'auto' || (!toolChoice && tools.length !== 0)) {
     return 'auto'
   }
-  if (toolChoice === 'none' || tools.length === 0) {
+  if (toolChoice === 'none') {
     return 'none'
   }
 
@@ -103,6 +106,14 @@ const mapToolToOpenAi = (tool: PromptTool): ChatCompletionTool => {
   }
 }
 
+const getTools = (promptTools: PromptTool[]): ChatCompletionTool[] | undefined => {
+  if (promptTools.length === 0) {
+    return undefined
+  }
+
+  return promptTools.map((tool) => mapToolToOpenAi(tool))
+}
+
 export const mapPromptToOpenAIConfig = (promptConfig: PromptConfiguration): ChatCompletionCreateParamsNonStreaming => {
   const { promptMessages, promptParameters, promptTools } = promptConfig
 
@@ -121,6 +132,6 @@ export const mapPromptToOpenAIConfig = (promptConfig: PromptConfiguration): Chat
     response_format: {
       type: promptParameters.responseFormat === 'JSON' ? 'json_object' : 'text'
     },
-    tools: promptTools.map((tool) => mapToolToOpenAi(tool))
+    tools: getTools(promptTools)
   }
 }

src/index.ts

@@ -1,6 +1,6 @@
 import Client from './Client'
 
 export * from './helpers'
-export type * from './types'
+export * from './types'
 
 export default Client

test/__fixtures__/promptConfiguration.ts

@@ -0,0 +1,21 @@
+import { PromptConfiguration } from '../../src'
+
+import { createPromptMessageFixture } from './promptMessage'
+
+export const createPromptConfigurationFixture = (overrides: Partial<PromptConfiguration> = {}): PromptConfiguration => ({
+  promptId: 'promptId',
+  promptMessages: [createPromptMessageFixture()],
+  promptParameters: {
+    modelName: 'text-davinci-002',
+    topP: 0.5,
+    maxTokens: 150,
+    temperature: 0.7,
+    seed: 42,
+    presencePenalty: 0.1,
+    frequencyPenalty: 0.1,
+    toolChoice: 'auto',
+    responseFormat: 'JSON'
+  },
+  promptTools: [],
+  ...overrides
+})

test/__fixtures__/promptMessage.ts

@@ -0,0 +1,9 @@
+import { PromptMessage, PromptMessageRoleEnum } from '../../src'
+
+export const createPromptMessageFixture = (overrides: Partial<PromptMessage> = {}): PromptMessage => ({
+  content: 'Hello world',
+  role: PromptMessageRoleEnum.USER,
+  toolCallId: null,
+  toolCalls: null,
+  ...overrides
+})

test/__fixtures__/promptTool.ts

@@ -0,0 +1,9 @@
+import { PromptTool } from '../../src'
+
+export const createPromptToolFixture = (overrides: Partial<PromptTool> = {}): PromptTool => ({
+  toolId: 'toolId',
+  description: 'description',
+  name: 'name',
+  parameters: {},
+  ...overrides
+})

tsconfig.json

@@ -3,7 +3,7 @@
     "incremental": true,
     "target": "es2017",
     "outDir": "build/main",
-    "rootDir": "src",
+    "rootDir": "./",
     "moduleResolution": "node",
     "module": "commonjs",
     "declaration": true,
@@ -28,7 +28,8 @@
     ]
   },
   "include": [
-    "src/**/*.ts"
+    "src/**/*.ts",
+    "test/**/*.ts"
   ],
   "exclude": [
     "node_modules/**"