Add tests for playground plugins and tool routes

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/fdb1a79a-ee3d-49d8-ac23-7ef960bf001d

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Claude

apps/studio/test/playground-plugins.test.ts

@@ -0,0 +1,90 @@
+// @vitest-environment happy-dom
+import { describe, it, expect } from 'vitest';
+import { agentPlaygroundPlugin, toolPlaygroundPlugin } from '../src/plugins/built-in';
+
+describe('Playground Plugins', () => {
+  describe('Agent Playground Plugin', () => {
+    it('should have correct manifest structure', () => {
+      expect(agentPlaygroundPlugin.manifest).toBeDefined();
+      expect(agentPlaygroundPlugin.manifest.id).toBe('objectstack.agent-playground');
+      expect(agentPlaygroundPlugin.manifest.name).toBe('Agent Playground');
+      expect(agentPlaygroundPlugin.activate).toBeTypeOf('function');
+    });
+
+    it('should contribute agent viewer for preview mode', () => {
+      const viewers = agentPlaygroundPlugin.manifest.contributes?.metadataViewers || [];
+      expect(viewers).toHaveLength(1);
+
+      const viewer = viewers[0];
+      expect(viewer.id).toBe('agent-playground');
+      expect(viewer.metadataTypes).toContain('agent');
+      expect(viewer.label).toBe('Playground');
+      expect(viewer.priority).toBe(10); // Higher than default inspector (-1)
+      expect(viewer.modes).toContain('preview');
+    });
+
+    it('should register viewer on activation', () => {
+      const registeredViewers: string[] = [];
+      const mockAPI = {
+        registerViewer: (id: string) => registeredViewers.push(id),
+        registerPanel: () => {},
+        registerAction: () => {},
+        registerCommand: () => {},
+        registerMetadataIcon: () => {},
+      };
+
+      agentPlaygroundPlugin.activate(mockAPI as any);
+      expect(registeredViewers).toContain('agent-playground');
+    });
+  });
+
+  describe('Tool Playground Plugin', () => {
+    it('should have correct manifest structure', () => {
+      expect(toolPlaygroundPlugin.manifest).toBeDefined();
+      expect(toolPlaygroundPlugin.manifest.id).toBe('objectstack.tool-playground');
+      expect(toolPlaygroundPlugin.manifest.name).toBe('Tool Playground');
+      expect(toolPlaygroundPlugin.activate).toBeTypeOf('function');
+    });
+
+    it('should contribute tool viewer for preview mode', () => {
+      const viewers = toolPlaygroundPlugin.manifest.contributes?.metadataViewers || [];
+      expect(viewers).toHaveLength(1);
+
+      const viewer = viewers[0];
+      expect(viewer.id).toBe('tool-playground');
+      expect(viewer.metadataTypes).toContain('tool');
+      expect(viewer.label).toBe('Playground');
+      expect(viewer.priority).toBe(10); // Higher than default inspector (-1)
+      expect(viewer.modes).toContain('preview');
+    });
+
+    it('should register viewer on activation', () => {
+      const registeredViewers: string[] = [];
+      const mockAPI = {
+        registerViewer: (id: string) => registeredViewers.push(id),
+        registerPanel: () => {},
+        registerAction: () => {},
+        registerCommand: () => {},
+        registerMetadataIcon: () => {},
+      };
+
+      toolPlaygroundPlugin.activate(mockAPI as any);
+      expect(registeredViewers).toContain('tool-playground');
+    });
+  });
+
+  describe('Plugin Priority', () => {
+    it('both playground plugins should have priority higher than default inspector', () => {
+      const agentViewers = agentPlaygroundPlugin.manifest.contributes?.metadataViewers || [];
+      const toolViewers = toolPlaygroundPlugin.manifest.contributes?.metadataViewers || [];
+
+      const agentPriority = agentViewers[0]?.priority ?? 0;
+      const toolPriority = toolViewers[0]?.priority ?? 0;
+
+      const defaultInspectorPriority = -1; // As defined in default-plugin.tsx
+
+      expect(agentPriority).toBeGreaterThan(defaultInspectorPriority);
+      expect(toolPriority).toBeGreaterThan(defaultInspectorPriority);
+    });
+  });
+});

packages/services/service-ai/src/__tests__/tool-routes.test.ts

@@ -0,0 +1,186 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { buildToolRoutes } from '../routes/tool-routes.js';
+import { AIService } from '../ai-service.js';
+import { InMemoryConversationService } from '../conversation/in-memory-conversation-service.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
+import type { Logger } from '@objectstack/spec/contracts';
+
+const silentLogger: Logger = {
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  fatal: vi.fn(),
+};
+
+describe('Tool Routes', () => {
+  let aiService: AIService;
+  let routes: ReturnType<typeof buildToolRoutes>;
+
+  beforeEach(() => {
+    const conversationService = new InMemoryConversationService();
+    aiService = new AIService({
+      adapter: 'memory',
+      conversationService,
+    });
+
+    // Register a test tool
+    aiService.toolRegistry.register({
+      name: 'test_tool',
+      description: 'A test tool for playground',
+      parameters: {
+        type: 'object',
+        properties: {
+          message: { type: 'string' },
+        },
+        required: ['message'],
+      },
+      handler: async (params: any) => {
+        return { echo: params.message };
+      },
+    });
+
+    routes = buildToolRoutes(aiService, silentLogger);
+  });
+
+  describe('GET /api/v1/ai/tools', () => {
+    it('should list all registered tools', async () => {
+      const listRoute = routes.find(r => r.method === 'GET' && r.path === '/api/v1/ai/tools');
+      expect(listRoute).toBeDefined();
+
+      const response = await listRoute!.handler({});
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('tools');
+      expect(Array.isArray((response.body as any).tools)).toBe(true);
+
+      const tools = (response.body as any).tools;
+      expect(tools.length).toBeGreaterThan(0);
+      expect(tools.some((t: any) => t.name === 'test_tool')).toBe(true);
+    });
+
+    it('should require authentication', () => {
+      const listRoute = routes.find(r => r.method === 'GET' && r.path === '/api/v1/ai/tools');
+      expect(listRoute?.auth).toBe(true);
+      expect(listRoute?.permissions).toContain('ai:tools');
+    });
+  });
+
+  describe('POST /api/v1/ai/tools/:toolName/execute', () => {
+    it('should execute a tool with parameters', async () => {
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+      expect(executeRoute).toBeDefined();
+
+      const response = await executeRoute!.handler({
+        params: { toolName: 'test_tool' },
+        body: {
+          parameters: { message: 'Hello, Playground!' },
+        },
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('result');
+      expect((response.body as any).result).toEqual({ echo: 'Hello, Playground!' });
+      expect((response.body as any).toolName).toBe('test_tool');
+      expect((response.body as any).duration).toBeTypeOf('number');
+    });
+
+    it('should return 404 for non-existent tool', async () => {
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+
+      const response = await executeRoute!.handler({
+        params: { toolName: 'non_existent_tool' },
+        body: {
+          parameters: {},
+        },
+      });
+
+      expect(response.status).toBe(404);
+      expect((response.body as any).error).toContain('not found');
+    });
+
+    it('should return 400 when toolName is missing', async () => {
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+
+      const response = await executeRoute!.handler({
+        body: {
+          parameters: {},
+        },
+      });
+
+      expect(response.status).toBe(400);
+      expect((response.body as any).error).toContain('toolName');
+    });
+
+    it('should return 400 when parameters are missing', async () => {
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+
+      const response = await executeRoute!.handler({
+        params: { toolName: 'test_tool' },
+        body: {},
+      });
+
+      expect(response.status).toBe(400);
+      expect((response.body as any).error).toContain('parameters');
+    });
+
+    it('should handle tool execution errors', async () => {
+      // Register a tool that throws an error
+      aiService.toolRegistry.register({
+        name: 'error_tool',
+        description: 'A tool that throws an error',
+        parameters: { type: 'object', properties: {} },
+        handler: async () => {
+          throw new Error('Tool execution failed');
+        },
+      });
+
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+
+      const response = await executeRoute!.handler({
+        params: { toolName: 'error_tool' },
+        body: {
+          parameters: {},
+        },
+      });
+
+      expect(response.status).toBe(500);
+      expect((response.body as any).error).toContain('Tool execution failed');
+      expect((response.body as any).duration).toBeTypeOf('number');
+    });
+
+    it('should require authentication and permissions', () => {
+      const executeRoute = routes.find(
+        r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'
+      );
+
+      expect(executeRoute?.auth).toBe(true);
+      expect(executeRoute?.permissions).toContain('ai:tools');
+      expect(executeRoute?.permissions).toContain('ai:execute');
+    });
+  });
+
+  describe('Route Configuration', () => {
+    it('should register exactly 2 routes', () => {
+      expect(routes).toHaveLength(2);
+    });
+
+    it('should have descriptive route descriptions', () => {
+      routes.forEach(route => {
+        expect(route.description).toBeTruthy();
+        expect(route.description.length).toBeGreaterThan(10);
+      });
+    });
+  });
+});