@futdevpro/nts-dynamo 1.15.38 → 1.15.40

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

@@ -1,106 +1,173 @@
-import { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
-import { DyFM_OAI_Model, DyFM_OAI_CallSettings } from '@futdevpro/fsm-dynamo/ai/open-ai';
-import { DyFM_AI_MessageRole, DyFM_AI_Tool, DyFM_AI_ToolHandlers } from '@futdevpro/fsm-dynamo/ai';
-
-/**
- * FR-047 — provider-agnosztikus function-calling agent-loop az OpenAI-wire fordítón keresztül.
- * Mockolt OpenAI klienssel teszteljük a teljes utat (translator + loop), halozat nelkul.
- */
-describe('| DyNTS_OAI_LLM_ServiceBase | requestWithTools (function calling)', (): void => {
-
-  function buildService(): DyNTS_OAI_LLM_ServiceBase {
-    return new DyNTS_OAI_LLM_ServiceBase({ config: { apiKey: 'test-key' } });
-  }
-
-  const tools: DyFM_AI_Tool[] = [
-    { name: 'get_x', description: 'returns x', parameters: { type: 'object', properties: {} } },
-  ];
-
-  const toolSettings = new DyFM_OAI_CallSettings({ useModel: DyFM_OAI_Model.gpt55 });
-
-  it('| should run the tool handler and return the final answer (loop converges)', async (): Promise<void> => {
-    const service = buildService();
-
-    (spyOn(service.openai.chat.completions, 'create') as jasmine.Spy).and.returnValues(
-      Promise.resolve({
-        choices: [{ message: { role: 'assistant', content: '', tool_calls: [
-          { id: 'call_1', type: 'function', function: { name: 'get_x', arguments: '{"a":1}' } },
-        ] }, finish_reason: 'tool_calls' }],
-        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-        model: 'gpt-5.5',
-      } as any),
-      Promise.resolve({
-        choices: [{ message: { role: 'assistant', content: 'final answer', tool_calls: [] }, finish_reason: 'stop' }],
-        usage: { prompt_tokens: 2, completion_tokens: 2, total_tokens: 4 },
-        model: 'gpt-5.5',
-      } as any),
-    );
-
-    let receivedArgs: Record<string, unknown> = {};
-    const toolHandlers: DyFM_AI_ToolHandlers = {
-      get_x: (args: Record<string, unknown>): string => {
-        receivedArgs = args;
-        return 'x=42';
-      },
-    };
-
-    const response = await service.requestWithTools({
-      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'use the tool' }],
-      tools: tools,
-      toolHandlers: toolHandlers,
-      settings: toolSettings,
-      issuer: 'spec',
-    });
-
-    expect(receivedArgs).toEqual({ a: 1 });
-    expect(response.content).toBe('final answer');
-    expect((service.openai.chat.completions.create as jasmine.Spy).calls.count()).toBe(2);
-  });
-
-  it('| should NOT throw when the tool handler throws (error fed back to the model)', async (): Promise<void> => {
-    const service = buildService();
-
-    (spyOn(service.openai.chat.completions, 'create') as jasmine.Spy).and.returnValues(
-      Promise.resolve({
-        choices: [{ message: { role: 'assistant', content: '', tool_calls: [
-          { id: 'call_1', type: 'function', function: { name: 'get_x', arguments: '{}' } },
-        ] }, finish_reason: 'tool_calls' }],
-        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-        model: 'gpt-5.5',
-      } as any),
-      Promise.resolve({
-        choices: [{ message: { role: 'assistant', content: 'recovered', tool_calls: [] }, finish_reason: 'stop' }],
-        usage: { prompt_tokens: 2, completion_tokens: 2, total_tokens: 4 },
-        model: 'gpt-5.5',
-      } as any),
-    );
-
-    const toolHandlers: DyFM_AI_ToolHandlers = {
-      get_x: (): string => { throw new Error('boom'); },
-    };
-
-    const response = await service.requestWithTools({
-      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'use the tool' }],
-      tools: tools,
-      toolHandlers: toolHandlers,
-      settings: toolSettings,
-      issuer: 'spec',
-    });
-
-    // a loop nem dobott; a model "recovered" valaszt adott a hiba-string utan
-    expect(response.content).toBe('recovered');
-  });
-
-  it('| should reject tool use for a model that does not support function calling', async (): Promise<void> => {
-    const service = buildService();
-    const embeddingSettings = new DyFM_OAI_CallSettings({ useModel: DyFM_OAI_Model.textEmbedding_3Small });
-
-    await expectAsync(service.requestWithTools({
-      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'x' }],
-      tools: tools,
-      toolHandlers: {},
-      settings: embeddingSettings,
-      issuer: 'spec',
-    })).toBeRejected();
-  });
-});
+import { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
+import { DyFM_OAI_Model, DyFM_OAI_CallSettings } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyFM_AI_MessageRole, DyFM_AI_Tool, DyFM_AI_ToolHandlers } from '@futdevpro/fsm-dynamo/ai';
+
+/**
+ * FR-047 — provider-agnosztikus function-calling agent-loop az OpenAI-wire fordítón keresztül.
+ * Mockolt OpenAI klienssel teszteljük a teljes utat (translator + loop), halozat nelkul.
+ */
+describe('| DyNTS_OAI_LLM_ServiceBase | requestWithTools (function calling)', (): void => {
+
+  function buildService(): DyNTS_OAI_LLM_ServiceBase {
+    return new DyNTS_OAI_LLM_ServiceBase({ config: { apiKey: 'test-key' } });
+  }
+
+  const tools: DyFM_AI_Tool[] = [
+    { name: 'get_x', description: 'returns x', parameters: { type: 'object', properties: {} } },
+  ];
+
+  const toolSettings = new DyFM_OAI_CallSettings({ useModel: DyFM_OAI_Model.gpt55 });
+
+  it('| should run the tool handler and return the final answer (loop converges)', async (): Promise<void> => {
+    const service = buildService();
+
+    (spyOn(service.openai.chat.completions, 'create') as jasmine.Spy).and.returnValues(
+      Promise.resolve({
+        choices: [{ message: { role: 'assistant', content: '', tool_calls: [
+          { id: 'call_1', type: 'function', function: { name: 'get_x', arguments: '{"a":1}' } },
+        ] }, finish_reason: 'tool_calls' }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        model: 'gpt-5.5',
+      } as any),
+      Promise.resolve({
+        choices: [{ message: { role: 'assistant', content: 'final answer', tool_calls: [] }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 2, completion_tokens: 2, total_tokens: 4 },
+        model: 'gpt-5.5',
+      } as any),
+    );
+
+    let receivedArgs: Record<string, unknown> = {};
+    const toolHandlers: DyFM_AI_ToolHandlers = {
+      get_x: (args: Record<string, unknown>): string => {
+        receivedArgs = args;
+        return 'x=42';
+      },
+    };
+
+    const response = await service.requestWithTools({
+      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'use the tool' }],
+      tools: tools,
+      toolHandlers: toolHandlers,
+      settings: toolSettings,
+      issuer: 'spec',
+    });
+
+    expect(receivedArgs).toEqual({ a: 1 });
+    expect(response.content).toBe('final answer');
+    expect((service.openai.chat.completions.create as jasmine.Spy).calls.count()).toBe(2);
+  });
+
+  it('| should NOT throw when the tool handler throws (error fed back to the model)', async (): Promise<void> => {
+    const service = buildService();
+
+    (spyOn(service.openai.chat.completions, 'create') as jasmine.Spy).and.returnValues(
+      Promise.resolve({
+        choices: [{ message: { role: 'assistant', content: '', tool_calls: [
+          { id: 'call_1', type: 'function', function: { name: 'get_x', arguments: '{}' } },
+        ] }, finish_reason: 'tool_calls' }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        model: 'gpt-5.5',
+      } as any),
+      Promise.resolve({
+        choices: [{ message: { role: 'assistant', content: 'recovered', tool_calls: [] }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 2, completion_tokens: 2, total_tokens: 4 },
+        model: 'gpt-5.5',
+      } as any),
+    );
+
+    const toolHandlers: DyFM_AI_ToolHandlers = {
+      get_x: (): string => { throw new Error('boom'); },
+    };
+
+    const response = await service.requestWithTools({
+      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'use the tool' }],
+      tools: tools,
+      toolHandlers: toolHandlers,
+      settings: toolSettings,
+      issuer: 'spec',
+    });
+
+    // a loop nem dobott; a model "recovered" valaszt adott a hiba-string utan
+    expect(response.content).toBe('recovered');
+  });
+
+  it('| should reject tool use for a model that does not support function calling', async (): Promise<void> => {
+    const service = buildService();
+    const embeddingSettings = new DyFM_OAI_CallSettings({ useModel: DyFM_OAI_Model.textEmbedding_3Small });
+
+    await expectAsync(service.requestWithTools({
+      conversation: [{ role: DyFM_AI_MessageRole.user, content: 'x' }],
+      tools: tools,
+      toolHandlers: {},
+      settings: embeddingSettings,
+      issuer: 'spec',
+    })).toBeRejected();
+  });
+
+  describe('| request shaping', (): void => {
+
+    function finalResponse(): unknown {
+      return {
+        choices: [{ message: { role: 'assistant', content: 'ok', tool_calls: [] }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        model: 'gpt-5.5',
+      };
+    }
+
+    it('| should NOT send sampling params for a reasoning model (gpt-5.5)', async (): Promise<void> => {
+      const service = buildService();
+      const createSpy = spyOn(service.openai.chat.completions, 'create') as jasmine.Spy;
+      createSpy.and.returnValue(Promise.resolve(finalResponse() as any));
+
+      await service.requestWithTools({
+        conversation: [{ role: DyFM_AI_MessageRole.user, content: 'hi' }],
+        tools: tools,
+        toolHandlers: {},
+        settings: toolSettings,
+        issuer: 'spec',
+      });
+
+      const input: any = createSpy.calls.argsFor(0)[0];
+      expect(input.temperature).toBeUndefined();
+      expect(input.top_p).toBeUndefined();
+      expect(input.frequency_penalty).toBeUndefined();
+      expect(input.presence_penalty).toBeUndefined();
+    });
+
+    it('| should send sampling params for a non-reasoning model (gpt-4o)', async (): Promise<void> => {
+      const service = buildService();
+      const createSpy = spyOn(service.openai.chat.completions, 'create') as jasmine.Spy;
+      createSpy.and.returnValue(Promise.resolve(finalResponse() as any));
+
+      await service.requestWithTools({
+        conversation: [{ role: DyFM_AI_MessageRole.user, content: 'hi' }],
+        tools: tools,
+        toolHandlers: {},
+        settings: new DyFM_OAI_CallSettings({ useModel: DyFM_OAI_Model.gpt4o }),
+        issuer: 'spec',
+      });
+
+      const input: any = createSpy.calls.argsFor(0)[0];
+      expect(input.temperature).toBeDefined();
+      expect(input.top_p).toBeDefined();
+    });
+
+    it('| should omit tools/tool_choice when the tools array is empty (no empty-array 400)', async (): Promise<void> => {
+      const service = buildService();
+      const createSpy = spyOn(service.openai.chat.completions, 'create') as jasmine.Spy;
+      createSpy.and.returnValue(Promise.resolve(finalResponse() as any));
+
+      await service.requestWithTools({
+        conversation: [{ role: DyFM_AI_MessageRole.user, content: 'hi' }],
+        tools: [],
+        toolHandlers: {},
+        settings: toolSettings,
+        issuer: 'spec',
+      });
+
+      const input: any = createSpy.calls.argsFor(0)[0];
+      expect(input.tools).toBeUndefined();
+      expect(input.tool_choice).toBeUndefined();
+    });
+  });
+});