@multiplayer-app/ai-agent-node 0.0.1 → 0.1.0-beta.2

package/src/helpers/AIHelper.test.ts

@@ -1,375 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { AIHelper } from './AIHelper';
-import { ModelStore } from '../store/ModelStore';
-import { ConfigStore } from '../store/ConfigStore';
-import { MessageRole, AgentToolCallStatus } from '@multiplayer-app/ai-agent-types';
-import type { AgentMessage } from '@multiplayer-app/ai-agent-types';
-
-describe('AIHelper.getAssistantResponse', () => {
-  let modelStore: ModelStore;
-  let configStore: ConfigStore;
-
-  beforeAll(() => {
-    // Setup real ModelStore instance
-    modelStore = ModelStore.getInstance();
-    modelStore.setModels([
-      { id: 'openai/gpt-4o', label: 'GPT-4o Mini', provider: 'openrouter' }
-    ]);
-  });
-
-  describe('with tool approval responses', () => {
-    it('should handle approved tool with successful execution', async () => {
-      // Note: getAssistantResponse accepts Pick<AgentMessage, 'role' | 'content'>[]
-      // but convertMessages internally handles toolCalls, so we cast for testing
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Please execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tool for you.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'test-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: true,
-              output: { result: 'success', data: { executed: true } }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response (actual model call)
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // The response should acknowledge the tool execution
-      // (exact text depends on model, so we just verify it's a valid response)
-    }, 30000);
-
-    it('should handle denied tool with execution-denied output', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Please execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tool for you.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'test-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: false,
-              reason: 'User denied execution',
-              output: {
-                type: 'execution-denied',
-                reason: 'User denied execution'
-              }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response acknowledging the denial
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // The model should respond to the execution-denied output
-    }, 30000);
-
-    it('should handle multiple tools with mixed approvals', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Execute multiple tools'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tools.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'approved-tool',
-              input: { param: 'value1' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: true,
-              output: { result: 'approved-result' }
-            },
-            {
-              id: 'tool-call-2',
-              name: 'denied-tool',
-              input: { param: 'value2' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: false,
-              reason: 'Not allowed',
-              output: {
-                type: 'execution-denied',
-                reason: 'Not allowed'
-              }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response handling both tool results
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // The model should process both approved and denied tool results
-    }, 30000);
-
-    it('should handle tool execution failure', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'failing-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Failed,
-              approved: true,
-              error: 'Tool execution failed: Network error'
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response even when tool execution failed
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('should handle tool with execution-denied due to tool not found', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'missing-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: true,
-              output: {
-                type: 'execution-denied',
-                reason: 'Tool was not found'
-              }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response when tool was not found
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('should handle tool with execution-denied due to tool execution error', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I will execute the tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'error-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Succeeded,
-              approved: true,
-              output: {
-                type: 'execution-denied',
-                reason: 'Tool failed with error'
-              }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response when tool execution had an error
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('should handle messages without tool calls', async () => {
-      const messages: Pick<AgentMessage, 'role' | 'content'>[] = [
-        {
-          role: MessageRole.User,
-          content: 'Hello, how are you?'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I am doing well, thank you!'
-        }
-      ];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response for normal conversation
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('should handle tool calls without output (pending approval)', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'Execute the tool'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'I need to execute a tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'pending-tool',
-              input: { param: 'value' },
-              status: AgentToolCallStatus.Pending,
-              requiresConfirmation: true,
-              approvalId: 'approval-123'
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response even when tool is pending approval
-      // (tool calls without output should not include tool-result in messages)
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-    }, 30000);
-
-    it('should handle sequential tool approvals', async () => {
-      const messages = [
-        {
-          role: MessageRole.User,
-          content: 'First request'
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'Executing first tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-1',
-              name: 'first-tool',
-              input: { step: 1 },
-              status: AgentToolCallStatus.Succeeded,
-              approved: true,
-              output: { result: 'first-result' }
-            }
-          ]
-        },
-        {
-          role: MessageRole.Assistant,
-          content: 'Now executing second tool.',
-          toolCalls: [
-            {
-              id: 'tool-call-2',
-              name: 'second-tool',
-              input: { step: 2 },
-              status: AgentToolCallStatus.Succeeded,
-              approved: false,
-              reason: 'User denied',
-              output: {
-                type: 'execution-denied',
-                reason: 'User denied'
-              }
-            }
-          ]
-        }
-      ] as Pick<AgentMessage, 'role' | 'content' | 'toolCalls'>[];
-
-      const response = await AIHelper.getAssistantResponse(messages);
-
-      // Verify we get a response for sequential tool calls
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // The model should process both sequential tool results
-    }, 30000);
-
-    it('should pass through options correctly', async () => {
-      const messages: Pick<AgentMessage, 'role' | 'content'>[] = [
-        {
-          role: MessageRole.User,
-          content: 'Test message'
-        }
-      ];
-
-      const response = await AIHelper.getAssistantResponse(messages, undefined, {
-        temperature: 0.9,
-        maxOutputTokens: 1000
-      });
-
-      // Verify we get a response with custom options applied
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // Options are passed through to the model
-    }, 30000);
-
-    it('should handle abort signal', async () => {
-      const messages: Pick<AgentMessage, 'role' | 'content'>[] = [
-        {
-          role: MessageRole.User,
-          content: 'Test message'
-        }
-      ];
-
-      const abortController = new AbortController();
-      const signal = abortController.signal;
-
-      const response = await AIHelper.getAssistantResponse(messages, signal);
-
-      // Verify we get a response with abort signal passed through
-      expect(response).toBeDefined();
-      expect(typeof response).toBe('string');
-      expect(response.length).toBeGreaterThan(0);
-
-      // Signal is passed through to the model for cancellation support
-    }, 30000);
-  });
-});