@futdevpro/nts-dynamo 1.15.1 → 1.15.3

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

@@ -0,0 +1,229 @@
+
+import { DyNTS_AI_LLMChat_ServiceBase } from './ai-llm-chat.service-base';
+import { DyNTS_AI_LLM_ServiceBase } from './ai-llm.service-base';
+import { DyFM_AI_CallSettings, DyFM_AI_MessageRole, DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_AI_ConversationBase_Input, DyFM_AI_ConversationGenericSelect_Input, DyFM_AI_ConversationGenericMultiSelect_Input, DyFM_AI_ConversationJSONKeysDescription_Input, DyFM_AI_ConversationJSONExactKeys_Input } from '../_models/ai-input-interfaces';
+
+class TestLLMChatService extends DyNTS_AI_LLMChat_ServiceBase<DyFM_AI_CallSettings> {
+  readonly aiProvider: any = {} as any;
+  readonly capabilities: any = {} as any;
+  setup = (config: any): void => {};
+  testConnection = async (issuer: string): Promise<boolean> => true;
+  readonly defaultSettings: DyFM_AI_CallSettings = {
+    systemPrompt: 'Test system prompt',
+    useModel: 'test-model',
+    debugLog: false,
+  };
+
+  readonly predefinedRequests = {
+    yesNo: {
+      upperCaseYes: 'YES',
+    },
+  };
+
+  requestSimpleMessage = async (set: any): Promise<string> => { return ''; };
+  requestYesNo = async (set: any): Promise<boolean> => { return false; };
+  requestPercentage = async (set: any): Promise<number> => { return 0; };
+  requestSelect = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestMultiselect = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };
+  requestJSON = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestJSONQuestionWithKeysDescription = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestJSONWithExactKeys = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestList = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };
+
+  async requestSimpleMessageInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<string> {
+    return 'Test response';
+  }
+
+  async requestYesNoInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<boolean> {
+    return true;
+  }
+
+  async requestPercentageInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<number> {
+    return 50;
+  }
+
+  async requestSelectInConversation<T>(set: DyFM_AI_ConversationGenericSelect_Input<T, DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
+    return null as any;
+  }
+
+  async requestMultiselectInConversation<T>(set: DyFM_AI_ConversationGenericMultiSelect_Input<T, DyFM_AI_CallSettings>): Promise<T[] | { unparsableResult: string }> {
+    return [];
+  }
+
+  async requestJSONInConversation<T = any>(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
+    return null as any;
+  }
+
+  async requestJSONInConversationWithKeysDescription<T>(set: DyFM_AI_ConversationJSONKeysDescription_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
+    return null as any;
+  }
+
+  async requestJSONInConversationWithExactKeys<T>(set: DyFM_AI_ConversationJSONExactKeys_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
+    return null as any;
+  }
+
+  async requestListInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<string[] | { unparsableResult: string }> {
+    return [];
+  }
+
+  static getInstance(): TestLLMChatService {
+    return TestLLMChatService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_AI_LLMChat_ServiceBase', () => {
+  let service: TestLLMChatService;
+
+  beforeEach(() => {
+    service = new (TestLLMChatService as any)();
+  });
+
+  describe('| constructor', () => {
+    it('| should extend LLM service base', () => {
+      expect(service).toBeInstanceOf(DyNTS_AI_LLM_ServiceBase);
+    });
+  });
+
+  describe('| requestSimpleMessageInConversation', () => {
+    it('| should request simple message in conversation', async () => {
+      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Hello' },
+        ],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestSimpleMessageInConversation(input);
+
+      expect(result).toBe('Test response');
+    });
+  });
+
+  describe('| requestYesNoInConversation', () => {
+    it('| should request yes/no in conversation', async () => {
+      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Is this true?' },
+        ],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestYesNoInConversation(input);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('| requestPercentageInConversation', () => {
+    it('| should request percentage in conversation', async () => {
+      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'What percentage?' },
+        ],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestPercentageInConversation(input);
+
+      expect(result).toBe(50);
+    });
+  });
+
+  describe('| requestSelectInConversation', () => {
+    it('| should request select in conversation', async () => {
+      const input: DyFM_AI_ConversationGenericSelect_Input<string, DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Choose one' },
+        ],
+        selectFrom: ['option1', 'option2'],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestSelectInConversation(input);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('| requestMultiselectInConversation', () => {
+    it('| should request multiselect in conversation', async () => {
+      const input: DyFM_AI_ConversationGenericMultiSelect_Input<string, DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Choose multiple' },
+        ],
+        options: ['option1', 'option2'],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestMultiselectInConversation(input);
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('| requestJSONInConversation', () => {
+    it('| should request JSON in conversation', async () => {
+      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Return JSON' },
+        ],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestJSONInConversation(input);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('| requestJSONInConversationWithKeysDescription', () => {
+    it('| should request JSON with keys description in conversation', async () => {
+      const input: DyFM_AI_ConversationJSONKeysDescription_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Return JSON with keys' },
+        ],
+        keysDescription: 'key1: Description 1',
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestJSONInConversationWithKeysDescription(input);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('| requestJSONInConversationWithExactKeys', () => {
+    it('| should request JSON with exact keys in conversation', async () => {
+      const input: DyFM_AI_ConversationJSONExactKeys_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Return JSON with exact keys' },
+        ],
+        keys: ['key1', 'key2'],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestJSONInConversationWithExactKeys(input);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('| requestListInConversation', () => {
+    it('| should request list in conversation', async () => {
+      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
+        conversation: [
+          { role: DyFM_AI_MessageRole.user, content: 'Return list' },
+        ],
+        issuer: 'test-issuer',
+      };
+
+      const result = await service.requestListInConversation(input);
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+});
+

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

@@ -0,0 +1,250 @@
+
+import { DyNTS_AI_LLM_ServiceBase } from './ai-llm.service-base';
+import { DyFM_AI_CallSettings, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_Log, DyFM_Object } from '@futdevpro/fsm-dynamo';
+
+class TestLLMService extends DyNTS_AI_LLM_ServiceBase<DyFM_AI_CallSettings> {
+  readonly aiProvider: any = {} as any;
+  readonly capabilities: any = {} as any;
+  setup = (config: any): void => {};
+  testConnection = async (issuer: string): Promise<boolean> => true;
+  readonly defaultSettings: DyFM_AI_CallSettings = {
+    systemPrompt: 'Test system prompt',
+    useModel: 'test-model',
+    debugLog: false,
+  };
+
+  readonly predefinedRequests = {
+    yesNo: {
+      upperCaseYes: 'YES',
+    },
+  };
+
+  requestSimpleMessage = async (set: any): Promise<string> => { return ''; };
+  requestYesNo = async (set: any): Promise<boolean> => { return false; };
+  requestPercentage = async (set: any): Promise<number> => { return 0; };
+  requestSelect = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestMultiselect = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };
+  requestJSON = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestJSONQuestionWithKeysDescription = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestJSONWithExactKeys = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
+  requestList = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };
+
+  static getInstance(): TestLLMService {
+    return TestLLMService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_AI_LLM_ServiceBase', () => {
+  let service: TestLLMService;
+
+  beforeEach(() => {
+    service = TestLLMService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestLLMService.getInstance();
+    const instance2 = TestLLMService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestLLMService);
+  });
+
+  describe('| defaultSystemPrompt', () => {
+    it('| should return system prompt from default settings', () => {
+      expect(service.defaultSystemPrompt).toBe('Test system prompt');
+    });
+  });
+
+  describe('| defaultModel', () => {
+    it('| should return model from default settings', () => {
+      expect(service.defaultModel).toBe('test-model');
+    });
+  });
+
+  describe('| debugLog', () => {
+    it('| should return debugLog from default settings', () => {
+      expect(service.debugLog).toBe(false);
+    });
+
+    it('| should return _debugLog when defaultSettings debugLog is not set', () => {
+      const serviceWithoutDebugLog = new (class extends TestLLMService {
+        override readonly defaultSettings: DyFM_AI_CallSettings = {
+          systemPrompt: 'Test',
+          useModel: 'test',
+        };
+        override readonly aiProvider: any = {} as any;
+        override readonly capabilities: any = {} as any;
+        override setup = (config: any): void => {};
+        override testConnection = async (issuer: string): Promise<boolean> => true;
+      } as any)();
+
+      // Set _debugLog on the new instance
+      serviceWithoutDebugLog._debugLog = true;
+      expect(serviceWithoutDebugLog.debugLog).toBe(true);
+    });
+  });
+
+  describe('| convertAnswerToBoolean', () => {
+    it('| should return true when answer contains YES', () => {
+      const result = (service as any).convertAnswerToBoolean('YES');
+
+      expect(result).toBe(true);
+    });
+
+    it('| should return true when answer contains yes in uppercase', () => {
+      const result = (service as any).convertAnswerToBoolean('The answer is YES');
+
+      expect(result).toBe(true);
+    });
+
+    it('| should return false when answer does not contain YES', () => {
+      const result = (service as any).convertAnswerToBoolean('NO');
+
+      expect(result).toBe(false);
+    });
+
+    it('| should be case insensitive', () => {
+      const result = (service as any).convertAnswerToBoolean('yes');
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('| convertAnswerToNumber', () => {
+    it('| should return number when answer is valid', () => {
+      const result = (service as any).convertAnswerToNumber('42', 'What is the answer?');
+
+      expect(result).toBe(42);
+    });
+
+    it('| should return null when answer is invalid (contains skip flag)', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(true);
+
+      const result = (service as any).convertAnswerToNumber('42', 'What is the answer?');
+
+      expect(result).toBeNull();
+    });
+
+    it('| should return null when answer is NaN', () => {
+      const logSpy = spyOn(DyFM_Log, 'T_error');
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+
+      const result = (service as any).convertAnswerToNumber('not-a-number', 'What is the answer?');
+
+      expect(result).toBeNull();
+      expect(logSpy).toHaveBeenCalled();
+    });
+
+    it('| should handle decimal numbers', () => {
+      const result = (service as any).convertAnswerToNumber('42.5', 'What is the answer?');
+
+      expect(result).toBe(42.5);
+    });
+  });
+
+  describe('| convertAnswerToSelectOption', () => {
+    it('| should return selected option when found', () => {
+      const options = ['option1', 'option2', 'option3'];
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2', 'option3']);
+
+      const result = (service as any).convertAnswerToSelectOption('option1', 'Select an option', options);
+
+      expect(result).toBe('option1');
+    });
+
+    it('| should return null when answer is invalid', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(true);
+
+      const result = (service as any).convertAnswerToSelectOption('option1', 'Select an option', ['option1']);
+
+      expect(result).toBeNull();
+    });
+
+    it('| should return null when option not found', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(service as any, 'stringifySelectOptions').and.returnValue(['option1', 'option2']);
+
+      const result = (service as any).convertAnswerToSelectOption('option3', 'Select an option', ['option1', 'option2']);
+
+      expect(result).toBeNull();
+    });
+
+    it('| should handle JSON options', () => {
+      const options = [{ id: 1, name: 'test' }];
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(service as any, 'stringifySelectOptions').and.returnValue([JSON.stringify({ id: 1, name: 'test' })]);
+      spyOn(DyFM_Object, 'safeParseJSON').and.returnValue({ id: 1, name: 'test' });
+
+      const result = (service as any).convertAnswerToSelectOption(
+        JSON.stringify({ id: 1, name: 'test' }),
+        'Select an option',
+        options
+      );
+
+      expect(result).toEqual({ id: 1, name: 'test' });
+    });
+  });
+
+  describe('| convertAnswerToSelectOptions', () => {
+    it('| should return multiple selected options', () => {
+      const options = ['option1', 'option2', 'option3'];
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(service as any, 'stringifySelectOption').and.callFake((opt: string) => opt);
+
+      const result = (service as any).convertAnswerToSelectOptions('option1 and option2', 'Select options', options);
+
+      expect(result).toEqual(['option1', 'option2']);
+    });
+
+    it('| should return null when answer is invalid', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(true);
+
+      const result = (service as any).convertAnswerToSelectOptions('option1', 'Select options', ['option1']);
+
+      expect(result).toBeNull();
+    });
+
+    it('| should return empty array when no options match', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(service as any, 'stringifySelectOption').and.callFake((opt: string) => opt);
+
+      const result = (service as any).convertAnswerToSelectOptions('option4', 'Select options', ['option1', 'option2']);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('| convertAnswerToJSON', () => {
+    it('| should return parsed JSON when valid', () => {
+      const jsonString = '{"key": "value"}';
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(DyFM_Object, 'safeParseJSON').and.returnValue({ key: 'value' });
+
+      const result = (service as any).convertAnswerToJSON(jsonString, 'Enter JSON') as { key: string };
+
+      expect(result).toEqual({ key: 'value' });
+    });
+
+    it('| should return unparsableResult when answer is invalid', () => {
+      spyOn(service as any, 'isAnswerValid').and.returnValue(true);
+
+      const result = (service as any).convertAnswerToJSON('{"key": "value"}', 'Enter JSON');
+
+      expect(result).toEqual({ unparsableResult: '{"key": "value"}' });
+    });
+
+    it('| should return unparsableResult when JSON is invalid', () => {
+      const logSpy = spyOn(DyFM_Log, 'T_error');
+      spyOn(service as any, 'isAnswerValid').and.returnValue(false);
+      spyOn(DyFM_Object, 'safeParseJSON').and.returnValue({ unparsableResult: 'invalid json' });
+
+      const result = (service as any).convertAnswerToJSON('invalid json', 'Enter JSON');
+
+      expect(result).toEqual({ unparsableResult: 'invalid json' });
+      expect(logSpy).toHaveBeenCalled();
+    });
+  });
+});
+

package/src/_modules/ai/_services/ai-provider.service-base.spec.ts

@@ -0,0 +1,79 @@
+
+import { DyNTS_AI_Provider_ServiceBase } from './ai-provider.service-base';
+import { DyFM_AI_Provider, DyFM_AI_ProviderCapabilities, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
+
+class TestProviderService extends DyNTS_AI_Provider_ServiceBase {
+  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.OpenAI;
+  readonly capabilities: DyFM_AI_ProviderCapabilities = {
+    chat: true,
+    embeddings: true,
+    imageGeneration: false,
+    vision: false,
+    audioGeneration: false,
+    audioAnalysis: false,
+    functionCalling: false,
+    streaming: false,
+    batchOperations: false,
+    supportedModelTypes: [],
+  };
+
+  setup = (config: DyFM_AI_Config): void => {
+    // Mock implementation
+  };
+
+  testConnection = async (issuer: string): Promise<boolean> => {
+    return true;
+  };
+
+  static getInstance(): TestProviderService {
+    return TestProviderService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_AI_Provider_ServiceBase', () => {
+  let service: TestProviderService;
+
+  beforeEach(() => {
+    service = TestProviderService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestProviderService.getInstance();
+    const instance2 = TestProviderService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestProviderService);
+  });
+
+  it('| should have aiProvider property', () => {
+    expect(service.aiProvider).toBe(DyFM_AI_Provider.OpenAI);
+  });
+
+  it('| should have capabilities property', () => {
+    expect(service.capabilities).toBeDefined();
+    expect(service.capabilities.chat).toBe(true);
+    expect(service.capabilities.embeddings).toBe(true);
+    expect(service.capabilities.chat).toBe(true);
+  });
+
+  describe('| setup', () => {
+    it('| should accept config parameter', () => {
+      const config: DyFM_AI_Config = {
+        apiKey: 'test-key',
+      };
+
+      expect(() => {
+        service.setup(config);
+      }).not.toThrow();
+    });
+  });
+
+  describe('| testConnection', () => {
+    it('| should return true when connection is successful', async () => {
+      const result = await service.testConnection('issuer-123');
+
+      expect(result).toBe(true);
+    });
+  });
+});
+