Fix tool-routes.ts to use ToolRegistry.execute() API

- Fixed ToolRegistry API usage (use has() and execute() instead of non-existent get() method)
- Added extractOutputValue() helper to safely handle different output types
- Updated tests to use correct ToolRegistry.register() signature (separate definition and handler params)
- Fixed test expectations to match string output from handlers
- All builds and tests now passing

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/4239d194-ecf4-4513-9729-f161ab40710d

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

Author: Claude

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

@@ -27,20 +27,22 @@ describe('Tool Routes', () => {
     });
 
     // Register a test tool
-    aiService.toolRegistry.register({
-      name: 'test_tool',
-      description: 'A test tool for playground',
-      parameters: {
-        type: 'object',
-        properties: {
-          message: { type: 'string' },
+    aiService.toolRegistry.register(
+      {
+        name: 'test_tool',
+        description: 'A test tool for playground',
+        parameters: {
+          type: 'object',
+          properties: {
+            message: { type: 'string' },
+          },
+          required: ['message'],
         },
-        required: ['message'],
       },
-      handler: async (params: any) => {
-        return { echo: params.message };
-      },
-    });
+      async (params: any) => {
+        return JSON.stringify({ echo: params.message });
+      }
+    );
 
     routes = buildToolRoutes(aiService, silentLogger);
   });
@@ -83,7 +85,8 @@ describe('Tool Routes', () => {
 
       expect(response.status).toBe(200);
       expect(response.body).toHaveProperty('result');
-      expect((response.body as any).result).toEqual({ echo: 'Hello, Playground!' });
+      // Result is a JSON string from the handler
+      expect((response.body as any).result).toBe('{"echo":"Hello, Playground!"}');
       expect((response.body as any).toolName).toBe('test_tool');
       expect((response.body as any).duration).toBeTypeOf('number');
     });
@@ -135,14 +138,16 @@ describe('Tool Routes', () => {
 
     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');
+      aiService.toolRegistry.register(
+        {
+          name: 'error_tool',
+          description: 'A tool that throws an error',
+          parameters: { type: 'object', properties: {} },
         },
-      });
+        async () => {
+          throw new Error('Tool execution failed');
+        }
+      );
 
       const executeRoute = routes.find(
         r => r.method === 'POST' && r.path === '/api/v1/ai/tools/:toolName/execute'

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

@@ -4,6 +4,18 @@ import type { Logger } from '@objectstack/spec/contracts';
 import type { AIService } from '../ai-service.js';
 import type { RouteDefinition } from './ai-routes.js';
 
+/**
+ * Extract string value from tool execution result output.
+ */
+function extractOutputValue(output: any): string {
+  if (!output) return '';
+  if (typeof output === 'string') return output;
+  if (typeof output === 'object' && 'value' in output) {
+    return String(output.value ?? '');
+  }
+  return JSON.stringify(output);
+}
+
 /**
  * Build tool-specific REST routes.
  *
@@ -75,39 +87,44 @@ export function buildToolRoutes(
         }
 
         try {
-          // Look up the tool
-          const tool = aiService.toolRegistry.get(toolName);
-          if (!tool) {
+          // Check if tool exists
+          if (!aiService.toolRegistry.has(toolName)) {
             return { status: 404, body: { error: `Tool "${toolName}" not found` } };
           }
 
-          // Execute the tool
+          // Execute the tool using ToolRegistry's execute method
           const startTime = Date.now();
-          let result: any;
 
-          try {
-            result = await tool.handler(parameters);
-          } catch (err) {
-            const duration = Date.now() - startTime;
+          const toolCallPart = {
+            type: 'tool-call' as const,
+            toolCallId: `playground-${Date.now()}`,
+            toolName,
+            input: parameters,
+          };
+
+          const result = await aiService.toolRegistry.execute(toolCallPart);
+          const duration = Date.now() - startTime;
+
+          // Check if execution resulted in an error
+          if (result.isError) {
+            const errorMsg = extractOutputValue(result.output);
             logger.error(
               `[AI Route] Tool execution error: ${toolName}`,
-              err instanceof Error ? err : undefined,
+              new Error(errorMsg),
             );
             return {
               status: 500,
               body: {
-                error: err instanceof Error ? err.message : 'Tool execution failed',
+                error: errorMsg,
                 duration,
               },
             };
           }
 
-          const duration = Date.now() - startTime;
-
           return {
             status: 200,
             body: {
-              result,
+              result: extractOutputValue(result.output),
               duration,
               toolName,
             },