@futdevpro/nts-dynamo 1.15.136 → 1.15.139

package/src/_modules/ai/_modules/open-ai/_services/oai-llm.service-base.spec.ts

@@ -1,489 +1,489 @@
-
-import { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
-import { DyFM_OAI_Settings, DyFM_OAI_Model, DyFM_OAI_CallSettings } from '@futdevpro/fsm-dynamo/ai/open-ai';
-import { DyFM_AI_MessageRole, DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { ChatCompletion } from 'openai/resources';
-
-describe('| DyNTS_OAI_LLM_ServiceBase', () => {
-  let service: DyNTS_OAI_LLM_ServiceBase;
-  let mockOpenAI: any;
-  let mockChatCompletionsCreate: jasmine.Spy;
-  let mockModelsList: jasmine.Spy;
-
-  const mockSettings: DyFM_OAI_Settings = {
-    config: {
-      apiKey: 'test-api-key',
-      organization: 'test-org',
-    },
-    defaultSettings: {
-      useModel: DyFM_OAI_Model.gpt4o_mini,
-      systemPrompt: 'Test system prompt',
-      temperature: 0.7,
-      maxTokens: 1000,
-    },
-  };
-
-  beforeEach(() => {
-    mockChatCompletionsCreate = jasmine.createSpy('chat.completions.create').and.returnValue({
-      id: 'chatcmpl-123',
-      object: 'chat.completion',
-      created: 1234567890,
-      model: 'gpt-4o-mini',
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: 'assistant',
-            content: 'Test response',
-          },
-          finish_reason: 'stop',
-        },
-      ],
-      usage: {
-        prompt_tokens: 10,
-        completion_tokens: 5,
-        total_tokens: 15,
-      },
-    });
-
-    mockModelsList = jasmine.createSpy('models.list').and.returnValue({
-      data: [],
-    });
-
-    mockOpenAI = {
-      chat: {
-        completions: {
-          create: mockChatCompletionsCreate,
-        },
-      },
-      models: {
-        list: mockModelsList,
-      },
-    };
-
-    service = new DyNTS_OAI_LLM_ServiceBase(mockSettings);
-    (service as any).openai = mockOpenAI;
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with provided settings', () => {
-      expect(service.defaultSettings).toEqual(mockSettings.defaultSettings);
-      expect(service.aiProvider).toBeDefined();
-      expect(service.capabilities).toBeDefined();
-    });
-
-    it('| should initialize with default settings when not provided', () => {
-      // Creating service without settings requires OPENAI_API_KEY env var or throws
-      // Test that service creation with settings works and uses defaults for missing values
-      const serviceWithPartialSettings = new DyNTS_OAI_LLM_ServiceBase({
-        config: { apiKey: 'test-key' },
-      });
-      expect(serviceWithPartialSettings.defaultSettings).toBeDefined();
-    });
-
-    it('| should set defaultModel from defaultSettings', () => {
-      expect(service.defaultModel).toBe(DyFM_OAI_Model.gpt4o_mini);
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should reinitialize OpenAI client with new config', () => {
-      const newConfig = {
-        apiKey: 'new-api-key',
-        organization: 'new-org',
-      };
-
-      service.setup(newConfig);
-
-      expect((service as any).openai).toBeDefined();
-    });
-  });
-
-  describe('| requestYesNo', () => {
-    it('| should return true when answer contains YES', async () => {
-      mockChatCompletionsCreate.and.returnValue({
-        choices: [
-          {
-            message: {
-              content: 'YES',
-            },
-          },
-        ],
-      });
-
-      spyOn(service as any, 'convertAnswerToBoolean').and.returnValue(true);
-
-      const result = await service.requestYesNo({
-        message: 'Is this a test?',
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toBe(true);
-      expect((service as any).convertAnswerToBoolean).toHaveBeenCalled();
-    });
-
-    it('| should append predefined request to message', async () => {
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('YES'));
-
-      await service.requestYesNo({
-        message: 'Is this a test?',
-        issuer: 'test-issuer',
-      });
-
-      expect(service.requestSimpleMessage).toHaveBeenCalled();
-      const callArgs = (service.requestSimpleMessage as jasmine.Spy).calls.mostRecent().args[0];
-      expect(callArgs.message).toContain('Is this a test?');
-    });
-  });
-
-  describe('| requestPercentage', () => {
-    it('| should return number from answer', async () => {
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('75'));
-      spyOn(service as any, 'convertAnswerToNumber').and.returnValue(75);
-
-      const result = await service.requestPercentage({
-        message: 'What percentage?',
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toBe(75);
-      expect((service as any).convertAnswerToNumber).toHaveBeenCalled();
-    });
-  });
-
-  describe('| requestSelect', () => {
-    it('| should return selected option', async () => {
-      const options = ['option1', 'option2', 'option3'];
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('option1'));
-      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2', 'option3']);
-      spyOn(service as any, 'getTextListAsText').and.returnValue('option1, option2, option3');
-      spyOn(service as any, 'convertAnswerToSelectOption').and.returnValue('option1');
-
-      const result = await service.requestSelect({
-        message: 'Select an option',
-        selectFrom: options,
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toBe('option1');
-    });
-  });
-
-  describe('| requestMultiselect', () => {
-    it('| should return multiple selected options', async () => {
-      const options = ['option1', 'option2', 'option3'];
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('option1 and option2'));
-      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2', 'option3']);
-      spyOn(service as any, 'getTextListAsText').and.returnValue('option1, option2, option3');
-      spyOn(service as any, 'convertAnswerToSelectOptions').and.returnValue(['option1', 'option2']);
-
-      const result = await service.requestMultiselect({
-        message: 'Select options',
-        options: options,
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toEqual(['option1', 'option2']);
-    });
-  });
-
-  describe('| requestJSON', () => {
-    it('| should return parsed JSON', async () => {
-      const jsonString = '{"key": "value"}';
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve(jsonString));
-      spyOn(service as any, 'convertAnswerToJSON').and.returnValue({ key: 'value' });
-
-      const result = await service.requestJSON<{ key: string }>({
-        message: 'Return JSON',
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toEqual({ key: 'value' });
-    });
-  });
-
-  describe('| requestList', () => {
-    it('| should return list of items', async () => {
-      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('item1, item2, item3'));
-      spyOn(service as any, 'convertAnswerToList').and.returnValue(['item1', 'item2', 'item3']);
-
-      const result = await service.requestList<string>({
-        message: 'Return a list',
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toEqual(['item1', 'item2', 'item3']);
-    });
-  });
-
-  describe('| requestSimpleMessage', () => {
-    it('| should resolve message and return answer', async () => {
-      spyOn(service as any, 'logQuestion');
-      spyOn(service as any, 'logAnswer');
-      spyOn(service, 'resolveMessage').and.returnValue(Promise.resolve('Test response'));
-
-      const result = await service.requestSimpleMessage({
-        message: 'Test question',
-        issuer: 'test-issuer',
-      });
-
-      expect(result).toBe('Test response');
-      expect((service as any).logQuestion).toHaveBeenCalled();
-      expect((service as any).logAnswer).toHaveBeenCalled();
-    });
-
-    it('| should add user message to conversation', async () => {
-      const conversation: DyFM_AI_Message[] = [];
-      spyOn(service, 'resolveMessage').and.returnValue(Promise.resolve('Test response'));
-
-      await service.requestSimpleMessage({
-        message: 'Test question',
-        conversation: conversation,
-        issuer: 'test-issuer',
-      });
-
-      expect(conversation.length).toBe(1);
-      expect(conversation[0].role).toBe(DyFM_AI_MessageRole.user);
-      expect(conversation[0].content).toBe('Test question');
-    });
-  });
-
-  describe('| resolveMessage', () => {
-    it('| should return string answer when getFullResponse is false', async () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      const result = await service.resolveMessage({
-        conversation: conversation,
-        issuer: 'test-issuer',
-        getFullResponse: false,
-      });
-
-      expect(result).toBe('Test response');
-      expect(mockChatCompletionsCreate).toHaveBeenCalled();
-    });
-
-    it('| should return full ChatCompletion when getFullResponse is true', async () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      const fullResponse: ChatCompletion = {
-        id: 'chatcmpl-123',
-        object: 'chat.completion',
-        created: 1234567890,
-        model: 'gpt-4o-mini',
-        choices: [
-          {
-            index: 0,
-            message: {
-              role: 'assistant',
-              content: 'Test response',
-              refusal: null,
-            },
-            logprobs: null,
-            finish_reason: 'stop',
-          },
-        ],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 5,
-          total_tokens: 15,
-        },
-      };
-
-      mockChatCompletionsCreate.and.returnValue(fullResponse);
-
-      const result = await service.resolveMessage({
-        conversation: conversation,
-        issuer: 'test-issuer',
-        getFullResponse: true,
-      });
-
-      expect(result).toEqual(fullResponse);
-    });
-
-    it('| should add system message to conversation', async () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      spyOn(service as any, 'getDefaultSystemMessage').and.returnValue({
-        role: DyFM_AI_MessageRole.system,
-        content: 'System prompt',
-      });
-
-      await service.resolveMessage({
-        conversation: conversation,
-        issuer: 'test-issuer',
-      });
-
-      expect(conversation[0].role).toBe(DyFM_AI_MessageRole.system);
-    });
-
-    it('| should handle API errors', async () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      mockChatCompletionsCreate.and.throwError(new Error('API Error'));
-
-      try {
-        await service.resolveMessage({
-          conversation: conversation,
-          issuer: 'test-issuer',
-        });
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-OLSB-RM0');
-      }
-    });
-  });
-
-  describe('| FR-002 cost-event emit', () => {
-
-    it('| should emit cost-event with llm-completion callType for single user message', async () => {
-      const received: any[] = [];
-      (service as any).onCostEvent = (e: any) => { received.push(e); };
-
-      await service.resolveMessage({
-        conversation: [{ role: DyFM_AI_MessageRole.user, content: 'Q?' }],
-        issuer: 'llm-issuer-1',
-      });
-
-      expect(received.length).toBe(1);
-      expect(received[0].callType).toBe('llm-completion');
-      expect(received[0].provider).toBe('open-ai');
-      expect(received[0].model).toBe(DyFM_OAI_Model.gpt4o_mini);
-      expect(received[0].tokensUsed.input).toBe(10);
-      expect(received[0].tokensUsed.output).toBe(5);
-      expect(received[0].tokensUsed.total).toBe(15);
-      expect(received[0].issuer).toBe('llm-issuer-1');
-      expect(received[0].timestamp).toBeInstanceOf(Date);
-      expect(received[0].durationMs).toBeGreaterThanOrEqual(0);
-      expect(received[0].estimatedCostUsd).toBeUndefined();
-    });
-
-    it('| should emit cost-event with llm-chat callType for multi-message conversation', async () => {
-      const received: any[] = [];
-      (service as any).onCostEvent = (e: any) => { received.push(e); };
-
-      await service.resolveMessage({
-        conversation: [
-          { role: DyFM_AI_MessageRole.user,      content: 'Q1?' },
-          { role: DyFM_AI_MessageRole.assistant, content: 'A1.' },
-          { role: DyFM_AI_MessageRole.user,      content: 'Q2?' },
-        ],
-        issuer: 'llm-issuer-chat',
-      });
-
-      expect(received.length).toBe(1);
-      expect(received[0].callType).toBe('llm-chat');
-    });
-
-    it('| constructor accepts onCostEvent option (non-breaking additive)', () => {
-      const cb: any = jasmine.createSpy('onCostEvent');
-      const s: DyNTS_OAI_LLM_ServiceBase = new DyNTS_OAI_LLM_ServiceBase({
-        ...mockSettings,
-        onCostEvent: cb,
-      });
-
-      expect((s as any).onCostEvent).toBe(cb);
-    });
-  });
-
-  describe('| getMessageCreateInput', () => {
-    it('| should create input with default settings', () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      const result = (service as any).getMessageCreateInput({
-        conversation: conversation,
-        issuer: 'test-issuer',
-      });
-
-      expect(result.model).toBe(DyFM_OAI_Model.gpt4o_mini);
-      expect(result.messages).toBeDefined();
-      expect(result.temperature).toBe(0.7);
-      expect(result.max_completion_tokens).toBe(1000);
-    });
-
-    it('| should use provided settings when available', () => {
-      const conversation: DyFM_AI_Message[] = [
-        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
-      ];
-
-      const customSettings: DyFM_OAI_CallSettings = {
-        useModel: DyFM_OAI_Model.gpt4o,
-        temperature: 0.9,
-        maxTokens: 2000,
-      };
-
-      const result = (service as any).getMessageCreateInput({
-        conversation: conversation,
-        issuer: 'test-issuer',
-        settings: customSettings,
-      });
-
-      expect(result.model).toBe(DyFM_OAI_Model.gpt4o);
-      expect(result.temperature).toBe(0.9);
-      expect(result.max_completion_tokens).toBe(2000);
-    });
-
-    it('| should handle errors', () => {
-      // Test that the method handles edge cases gracefully
-      // Passing null conversation may or may not throw depending on implementation
-      try {
-        const result = (service as any).getMessageCreateInput({
-          conversation: null as any,
-          issuer: 'test-issuer',
-        });
-        // If it doesn't throw, verify it returns something
-        expect(result).toBeDefined();
-      } catch (error) {
-        // If it throws, it should be a DyFM_Error
-        expect(error).toBeInstanceOf(DyFM_Error);
-      }
-    });
-  });
-
-  describe('| testConnection', () => {
-    it('| should return true when connection is successful', async () => {
-      const result = await service.testConnection('test-issuer');
-
-      expect(result).toBe(true);
-      expect(mockModelsList).toHaveBeenCalled();
-    });
-
-    it('| should return false when connection fails', async () => {
-      const logSpy = spyOn(DyFM_Log, 'error');
-      mockModelsList.and.throwError(new Error('Connection failed'));
-
-      const result = await service.testConnection('test-issuer');
-
-      expect(result).toBe(false);
-      expect(logSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should have aiProvider property', () => {
-      expect(service.aiProvider).toBeDefined();
-    });
-
-    it('| should have capabilities property', () => {
-      expect(service.capabilities).toBeDefined();
-      expect(service.capabilities.chat).toBe(true);
-      expect(service.capabilities.embeddings).toBe(true);
-    });
-
-    it('| should have predefinedRequests property', () => {
-      expect(service.predefinedRequests).toBeDefined();
-    });
-  });
-});
-
+
+import { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
+import { DyFM_OAI_Settings, DyFM_OAI_Model, DyFM_OAI_CallSettings } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyFM_AI_MessageRole, DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { ChatCompletion } from 'openai/resources';
+
+describe('| DyNTS_OAI_LLM_ServiceBase', () => {
+  let service: DyNTS_OAI_LLM_ServiceBase;
+  let mockOpenAI: any;
+  let mockChatCompletionsCreate: jasmine.Spy;
+  let mockModelsList: jasmine.Spy;
+
+  const mockSettings: DyFM_OAI_Settings = {
+    config: {
+      apiKey: 'test-api-key',
+      organization: 'test-org',
+    },
+    defaultSettings: {
+      useModel: DyFM_OAI_Model.gpt4o_mini,
+      systemPrompt: 'Test system prompt',
+      temperature: 0.7,
+      maxTokens: 1000,
+    },
+  };
+
+  beforeEach(() => {
+    mockChatCompletionsCreate = jasmine.createSpy('chat.completions.create').and.returnValue({
+      id: 'chatcmpl-123',
+      object: 'chat.completion',
+      created: 1234567890,
+      model: 'gpt-4o-mini',
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: 'Test response',
+          },
+          finish_reason: 'stop',
+        },
+      ],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 5,
+        total_tokens: 15,
+      },
+    });
+
+    mockModelsList = jasmine.createSpy('models.list').and.returnValue({
+      data: [],
+    });
+
+    mockOpenAI = {
+      chat: {
+        completions: {
+          create: mockChatCompletionsCreate,
+        },
+      },
+      models: {
+        list: mockModelsList,
+      },
+    };
+
+    service = new DyNTS_OAI_LLM_ServiceBase(mockSettings);
+    (service as any).openai = mockOpenAI;
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with provided settings', () => {
+      expect(service.defaultSettings).toEqual(mockSettings.defaultSettings);
+      expect(service.aiProvider).toBeDefined();
+      expect(service.capabilities).toBeDefined();
+    });
+
+    it('| should initialize with default settings when not provided', () => {
+      // Creating service without settings requires OPENAI_API_KEY env var or throws
+      // Test that service creation with settings works and uses defaults for missing values
+      const serviceWithPartialSettings = new DyNTS_OAI_LLM_ServiceBase({
+        config: { apiKey: 'test-key' },
+      });
+      expect(serviceWithPartialSettings.defaultSettings).toBeDefined();
+    });
+
+    it('| should set defaultModel from defaultSettings', () => {
+      expect(service.defaultModel).toBe(DyFM_OAI_Model.gpt4o_mini);
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should reinitialize OpenAI client with new config', () => {
+      const newConfig = {
+        apiKey: 'new-api-key',
+        organization: 'new-org',
+      };
+
+      service.setup(newConfig);
+
+      expect((service as any).openai).toBeDefined();
+    });
+  });
+
+  describe('| requestYesNo', () => {
+    it('| should return true when answer contains YES', async () => {
+      mockChatCompletionsCreate.and.returnValue({
+        choices: [
+          {
+            message: {
+              content: 'YES',
+            },
+          },
+        ],
+      });
+
+      spyOn(service as any, 'convertAnswerToBoolean').and.returnValue(true);
+
+      const result = await service.requestYesNo({
+        message: 'Is this a test?',
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toBe(true);
+      expect((service as any).convertAnswerToBoolean).toHaveBeenCalled();
+    });
+
+    it('| should append predefined request to message', async () => {
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('YES'));
+
+      await service.requestYesNo({
+        message: 'Is this a test?',
+        issuer: 'test-issuer',
+      });
+
+      expect(service.requestSimpleMessage).toHaveBeenCalled();
+      const callArgs = (service.requestSimpleMessage as jasmine.Spy).calls.mostRecent().args[0];
+      expect(callArgs.message).toContain('Is this a test?');
+    });
+  });
+
+  describe('| requestPercentage', () => {
+    it('| should return number from answer', async () => {
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('75'));
+      spyOn(service as any, 'convertAnswerToNumber').and.returnValue(75);
+
+      const result = await service.requestPercentage({
+        message: 'What percentage?',
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toBe(75);
+      expect((service as any).convertAnswerToNumber).toHaveBeenCalled();
+    });
+  });
+
+  describe('| requestSelect', () => {
+    it('| should return selected option', async () => {
+      const options = ['option1', 'option2', 'option3'];
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('option1'));
+      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2', 'option3']);
+      spyOn(service as any, 'getTextListAsText').and.returnValue('option1, option2, option3');
+      spyOn(service as any, 'convertAnswerToSelectOption').and.returnValue('option1');
+
+      const result = await service.requestSelect({
+        message: 'Select an option',
+        selectFrom: options,
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toBe('option1');
+    });
+  });
+
+  describe('| requestMultiselect', () => {
+    it('| should return multiple selected options', async () => {
+      const options = ['option1', 'option2', 'option3'];
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('option1 and option2'));
+      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2', 'option3']);
+      spyOn(service as any, 'getTextListAsText').and.returnValue('option1, option2, option3');
+      spyOn(service as any, 'convertAnswerToSelectOptions').and.returnValue(['option1', 'option2']);
+
+      const result = await service.requestMultiselect({
+        message: 'Select options',
+        options: options,
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toEqual(['option1', 'option2']);
+    });
+  });
+
+  describe('| requestJSON', () => {
+    it('| should return parsed JSON', async () => {
+      const jsonString = '{"key": "value"}';
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve(jsonString));
+      spyOn(service as any, 'convertAnswerToJSON').and.returnValue({ key: 'value' });
+
+      const result = await service.requestJSON<{ key: string }>({
+        message: 'Return JSON',
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('| requestList', () => {
+    it('| should return list of items', async () => {
+      spyOn(service, 'requestSimpleMessage').and.returnValue(Promise.resolve('item1, item2, item3'));
+      spyOn(service as any, 'convertAnswerToList').and.returnValue(['item1', 'item2', 'item3']);
+
+      const result = await service.requestList<string>({
+        message: 'Return a list',
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toEqual(['item1', 'item2', 'item3']);
+    });
+  });
+
+  describe('| requestSimpleMessage', () => {
+    it('| should resolve message and return answer', async () => {
+      spyOn(service as any, 'logQuestion');
+      spyOn(service as any, 'logAnswer');
+      spyOn(service, 'resolveMessage').and.returnValue(Promise.resolve('Test response'));
+
+      const result = await service.requestSimpleMessage({
+        message: 'Test question',
+        issuer: 'test-issuer',
+      });
+
+      expect(result).toBe('Test response');
+      expect((service as any).logQuestion).toHaveBeenCalled();
+      expect((service as any).logAnswer).toHaveBeenCalled();
+    });
+
+    it('| should add user message to conversation', async () => {
+      const conversation: DyFM_AI_Message[] = [];
+      spyOn(service, 'resolveMessage').and.returnValue(Promise.resolve('Test response'));
+
+      await service.requestSimpleMessage({
+        message: 'Test question',
+        conversation: conversation,
+        issuer: 'test-issuer',
+      });
+
+      expect(conversation.length).toBe(1);
+      expect(conversation[0].role).toBe(DyFM_AI_MessageRole.user);
+      expect(conversation[0].content).toBe('Test question');
+    });
+  });
+
+  describe('| resolveMessage', () => {
+    it('| should return string answer when getFullResponse is false', async () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      const result = await service.resolveMessage({
+        conversation: conversation,
+        issuer: 'test-issuer',
+        getFullResponse: false,
+      });
+
+      expect(result).toBe('Test response');
+      expect(mockChatCompletionsCreate).toHaveBeenCalled();
+    });
+
+    it('| should return full ChatCompletion when getFullResponse is true', async () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      const fullResponse: ChatCompletion = {
+        id: 'chatcmpl-123',
+        object: 'chat.completion',
+        created: 1234567890,
+        model: 'gpt-4o-mini',
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: 'assistant',
+              content: 'Test response',
+              refusal: null,
+            },
+            logprobs: null,
+            finish_reason: 'stop',
+          },
+        ],
+        usage: {
+          prompt_tokens: 10,
+          completion_tokens: 5,
+          total_tokens: 15,
+        },
+      };
+
+      mockChatCompletionsCreate.and.returnValue(fullResponse);
+
+      const result = await service.resolveMessage({
+        conversation: conversation,
+        issuer: 'test-issuer',
+        getFullResponse: true,
+      });
+
+      expect(result).toEqual(fullResponse);
+    });
+
+    it('| should add system message to conversation', async () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      spyOn(service as any, 'getDefaultSystemMessage').and.returnValue({
+        role: DyFM_AI_MessageRole.system,
+        content: 'System prompt',
+      });
+
+      await service.resolveMessage({
+        conversation: conversation,
+        issuer: 'test-issuer',
+      });
+
+      expect(conversation[0].role).toBe(DyFM_AI_MessageRole.system);
+    });
+
+    it('| should handle API errors', async () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      mockChatCompletionsCreate.and.throwError(new Error('API Error'));
+
+      try {
+        await service.resolveMessage({
+          conversation: conversation,
+          issuer: 'test-issuer',
+        });
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-OLSB-RM0');
+      }
+    });
+  });
+
+  describe('| FR-002 cost-event emit', () => {
+
+    it('| should emit cost-event with llm-completion callType for single user message', async () => {
+      const received: any[] = [];
+      (service as any).onCostEvent = (e: any) => { received.push(e); };
+
+      await service.resolveMessage({
+        conversation: [{ role: DyFM_AI_MessageRole.user, content: 'Q?' }],
+        issuer: 'llm-issuer-1',
+      });
+
+      expect(received.length).toBe(1);
+      expect(received[0].callType).toBe('llm-completion');
+      expect(received[0].provider).toBe('open-ai');
+      expect(received[0].model).toBe(DyFM_OAI_Model.gpt4o_mini);
+      expect(received[0].tokensUsed.input).toBe(10);
+      expect(received[0].tokensUsed.output).toBe(5);
+      expect(received[0].tokensUsed.total).toBe(15);
+      expect(received[0].issuer).toBe('llm-issuer-1');
+      expect(received[0].timestamp).toBeInstanceOf(Date);
+      expect(received[0].durationMs).toBeGreaterThanOrEqual(0);
+      expect(received[0].estimatedCostUsd).toBeUndefined();
+    });
+
+    it('| should emit cost-event with llm-chat callType for multi-message conversation', async () => {
+      const received: any[] = [];
+      (service as any).onCostEvent = (e: any) => { received.push(e); };
+
+      await service.resolveMessage({
+        conversation: [
+          { role: DyFM_AI_MessageRole.user,      content: 'Q1?' },
+          { role: DyFM_AI_MessageRole.assistant, content: 'A1.' },
+          { role: DyFM_AI_MessageRole.user,      content: 'Q2?' },
+        ],
+        issuer: 'llm-issuer-chat',
+      });
+
+      expect(received.length).toBe(1);
+      expect(received[0].callType).toBe('llm-chat');
+    });
+
+    it('| constructor accepts onCostEvent option (non-breaking additive)', () => {
+      const cb: any = jasmine.createSpy('onCostEvent');
+      const s: DyNTS_OAI_LLM_ServiceBase = new DyNTS_OAI_LLM_ServiceBase({
+        ...mockSettings,
+        onCostEvent: cb,
+      });
+
+      expect((s as any).onCostEvent).toBe(cb);
+    });
+  });
+
+  describe('| getMessageCreateInput', () => {
+    it('| should create input with default settings', () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      const result = (service as any).getMessageCreateInput({
+        conversation: conversation,
+        issuer: 'test-issuer',
+      });
+
+      expect(result.model).toBe(DyFM_OAI_Model.gpt4o_mini);
+      expect(result.messages).toBeDefined();
+      expect(result.temperature).toBe(0.7);
+      expect(result.max_completion_tokens).toBe(1000);
+    });
+
+    it('| should use provided settings when available', () => {
+      const conversation: DyFM_AI_Message[] = [
+        { role: DyFM_AI_MessageRole.user, content: 'Test question' },
+      ];
+
+      const customSettings: DyFM_OAI_CallSettings = {
+        useModel: DyFM_OAI_Model.gpt4o,
+        temperature: 0.9,
+        maxTokens: 2000,
+      };
+
+      const result = (service as any).getMessageCreateInput({
+        conversation: conversation,
+        issuer: 'test-issuer',
+        settings: customSettings,
+      });
+
+      expect(result.model).toBe(DyFM_OAI_Model.gpt4o);
+      expect(result.temperature).toBe(0.9);
+      expect(result.max_completion_tokens).toBe(2000);
+    });
+
+    it('| should handle errors', () => {
+      // Test that the method handles edge cases gracefully
+      // Passing null conversation may or may not throw depending on implementation
+      try {
+        const result = (service as any).getMessageCreateInput({
+          conversation: null as any,
+          issuer: 'test-issuer',
+        });
+        // If it doesn't throw, verify it returns something
+        expect(result).toBeDefined();
+      } catch (error) {
+        // If it throws, it should be a DyFM_Error
+        expect(error).toBeInstanceOf(DyFM_Error);
+      }
+    });
+  });
+
+  describe('| testConnection', () => {
+    it('| should return true when connection is successful', async () => {
+      const result = await service.testConnection('test-issuer');
+
+      expect(result).toBe(true);
+      expect(mockModelsList).toHaveBeenCalled();
+    });
+
+    it('| should return false when connection fails', async () => {
+      const logSpy = spyOn(DyFM_Log, 'error');
+      mockModelsList.and.throwError(new Error('Connection failed'));
+
+      const result = await service.testConnection('test-issuer');
+
+      expect(result).toBe(false);
+      expect(logSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('| properties', () => {
+    it('| should have aiProvider property', () => {
+      expect(service.aiProvider).toBeDefined();
+    });
+
+    it('| should have capabilities property', () => {
+      expect(service.capabilities).toBeDefined();
+      expect(service.capabilities.chat).toBe(true);
+      expect(service.capabilities.embeddings).toBe(true);
+    });
+
+    it('| should have predefinedRequests property', () => {
+      expect(service.predefinedRequests).toBeDefined();
+    });
+  });
+});
+