don't throw exception when the response is empty.

Author: jsonbailey

packages/ai-providers/server-ai-openai/__tests__/OpenAIProvider.test.ts

@@ -3,20 +3,18 @@ import { OpenAI } from 'openai';
 import { OpenAIProvider } from '../src/OpenAIProvider';
 
 // Mock OpenAI
-jest.mock('openai', () => {
-  return {
-    OpenAI: jest.fn().mockImplementation(() => ({
-      chat: {
-        completions: {
-          create: jest.fn().mockResolvedValue({
-            choices: [{ message: { content: 'Test response' } }],
-            usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
-          }),
-        },
+jest.mock('openai', () => ({
+  OpenAI: jest.fn().mockImplementation(() => ({
+    chat: {
+      completions: {
+        create: jest.fn().mockResolvedValue({
+          choices: [{ message: { content: 'Test response' } }],
+          usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+        }),
       },
-    })),
-  };
-});
+    },
+  })),
+}));
 
 describe('OpenAIProvider', () => {
   let mockOpenAI: jest.Mocked<OpenAI>;
@@ -27,7 +25,6 @@ describe('OpenAIProvider', () => {
     provider = new OpenAIProvider(mockOpenAI, 'gpt-3.5-turbo', {});
   });
 
-
   describe('createAIMetrics', () => {
     it('creates metrics with success=true and token usage', () => {
       const mockResponse = {
@@ -101,9 +98,7 @@ describe('OpenAIProvider', () => {
 
       (mockOpenAI.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse as any);
 
-      const messages = [
-        { role: 'user' as const, content: 'Hello!' },
-      ];
+      const messages = [{ role: 'user' as const, content: 'Hello!' }];
 
       const result = await provider.invokeModel(messages);
 
@@ -128,7 +123,7 @@ describe('OpenAIProvider', () => {
       });
     });
 
-    it('throws error when no content in response', async () => {
+    it('returns unsuccessful response when no content in response', async () => {
       const mockResponse = {
         choices: [
           {
@@ -141,25 +136,66 @@ describe('OpenAIProvider', () => {
 
       (mockOpenAI.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse as any);
 
-      const messages = [
-        { role: 'user' as const, content: 'Hello!' },
-      ];
+      const messages = [{ role: 'user' as const, content: 'Hello!' }];
+
+      const result = await provider.invokeModel(messages);
 
-      await expect(provider.invokeModel(messages)).rejects.toThrow('No content in OpenAI response');
+      expect(result).toEqual({
+        message: {
+          role: 'assistant',
+          content: '',
+        },
+        metrics: {
+          success: false,
+          usage: undefined,
+        },
+      });
     });
 
-    it('handles empty choices array', async () => {
+    it('returns unsuccessful response when choices array is empty', async () => {
       const mockResponse = {
         choices: [],
       };
 
       (mockOpenAI.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse as any);
 
-      const messages = [
-        { role: 'user' as const, content: 'Hello!' },
-      ];
+      const messages = [{ role: 'user' as const, content: 'Hello!' }];
+
+      const result = await provider.invokeModel(messages);
+
+      expect(result).toEqual({
+        message: {
+          role: 'assistant',
+          content: '',
+        },
+        metrics: {
+          success: false,
+          usage: undefined,
+        },
+      });
+    });
+
+    it('returns unsuccessful response when choices is undefined', async () => {
+      const mockResponse = {
+        // choices is missing entirely
+      };
+
+      (mockOpenAI.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse as any);
+
+      const messages = [{ role: 'user' as const, content: 'Hello!' }];
 
-      await expect(provider.invokeModel(messages)).rejects.toThrow('No content in OpenAI response');
+      const result = await provider.invokeModel(messages);
+
+      expect(result).toEqual({
+        message: {
+          role: 'assistant',
+          content: '',
+        },
+        metrics: {
+          success: false,
+          usage: undefined,
+        },
+      });
     });
   });
 

packages/ai-providers/server-ai-openai/src/OpenAIProvider.ts

@@ -19,7 +19,12 @@ export class OpenAIProvider extends AIProvider {
   private _modelName: string;
   private _parameters: Record<string, unknown>;
 
-  constructor(client: OpenAI, modelName: string, parameters: Record<string, unknown>, logger?: LDLogger) {
+  constructor(
+    client: OpenAI,
+    modelName: string,
+    parameters: Record<string, unknown>,
+    logger?: LDLogger,
+  ) {
     super(logger);
     this._client = client;
     this._modelName = modelName;
@@ -53,25 +58,27 @@ export class OpenAIProvider extends AIProvider {
     // Call OpenAI chat completions API
     const response = await this._client.chat.completions.create({
       model: this._modelName,
-      messages: messages,
+      messages,
       ...this._parameters,
     });
 
-    // Extract the first choice content
-    const choice = response.choices[0];
-    if (!choice?.message?.content) {
-      throw new Error('No content in OpenAI response');
+    // Generate metrics early (assumes success by default)
+    const metrics = OpenAIProvider.createAIMetrics(response);
+
+    // Safely extract the first choice content using optional chaining
+    const content = response?.choices?.[0]?.message?.content || '';
+
+    if (!content) {
+      this.logger?.warn('OpenAI response has no content available');
+      metrics.success = false;
     }
 
     // Create the assistant message
     const assistantMessage: LDMessage = {
       role: 'assistant',
-      content: choice.message.content,
+      content,
     };
 
-    // Extract metrics including token usage and success status
-    const metrics = OpenAIProvider.createAIMetrics(response);
-
     return {
       message: assistantMessage,
       metrics,
@@ -85,7 +92,6 @@ export class OpenAIProvider extends AIProvider {
     return this._client;
   }
 
-
   // =============================================================================
   // STATIC UTILITY METHODS
   // =============================================================================
@@ -107,11 +113,10 @@ export class OpenAIProvider extends AIProvider {
       };
     }
 
-    // OpenAI responses that complete successfully are considered successful
+    // OpenAI responses that complete successfully are considered successful by default
     return {
       success: true,
       usage,
     };
   }
-
 }