@objectstack/service-ai 4.0.2 → 4.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/service-ai",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "license": "Apache-2.0",
   "description": "AI Service for ObjectStack — implements IAIService with LLM adapter layer, conversation management, tool registry, and REST/SSE routes",
   "type": "module",
@@ -15,9 +15,9 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "^3.0.8",
-    "ai": "^6.0.146",
-    "@objectstack/core": "4.0.2",
-    "@objectstack/spec": "4.0.2"
+    "ai": "^6.0.158",
+    "@objectstack/core": "4.0.4",
+    "@objectstack/spec": "4.0.4"
   },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
@@ -40,9 +40,9 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.4"
   },
   "scripts": {
     "build": "tsup --config ../../../tsup.config.ts",

package/src/__tests__/ai-service.test.ts

@@ -818,6 +818,23 @@ describe('AIServicePlugin', () => {
     expect(ctx.replaceService).toHaveBeenCalledWith('ai', expect.any(Object));
   });
 
+  it('should contribute Setup navigation labels as plain strings', async () => {
+    const plugin = new AIServicePlugin();
+    const ctx = createMockContext();
+    const contribute = vi.fn();
+    ctx.registerService('setupNav', { contribute });
+
+    await plugin.init(ctx);
+
+    expect(contribute).toHaveBeenCalledWith({
+      areaId: 'area_ai',
+      items: [
+        expect.objectContaining({ id: 'nav_ai_conversations', label: 'Conversations' }),
+        expect.objectContaining({ id: 'nav_ai_messages', label: 'Messages' }),
+      ],
+    });
+  });
+
   it('should clean up on destroy', async () => {
     const plugin = new AIServicePlugin();
     const ctx = createMockContext();
@@ -868,7 +885,16 @@ describe('AIServicePlugin', () => {
   });
 
   it('should fallback to MemoryLLMAdapter when provider SDK is not installed', async () => {
-    const plugin = new AIServicePlugin();
+    // Mock all provider SDKs to simulate them not being installed.
+    // In the workspace @ai-sdk/openai may be resolvable as a transitive
+    // dependency, so we must explicitly make the dynamic import fail.
+    vi.doMock('@ai-sdk/openai', () => { throw new Error('Cannot find module \'@ai-sdk/openai\''); });
+    vi.doMock('@ai-sdk/anthropic', () => { throw new Error('Cannot find module \'@ai-sdk/anthropic\''); });
+    vi.doMock('@ai-sdk/google', () => { throw new Error('Cannot find module \'@ai-sdk/google\''); });
+
+    // Re-import the plugin module so it picks up the mocked imports
+    const { AIServicePlugin: FreshPlugin } = await import('../plugin.js');
+    const plugin = new FreshPlugin();
     const ctx = createMockContext();
 
     const oldEnv = { ...process.env };
@@ -897,6 +923,9 @@ describe('AIServicePlugin', () => {
       );
     } finally {
       process.env = oldEnv;
+      vi.doUnmock('@ai-sdk/openai');
+      vi.doUnmock('@ai-sdk/anthropic');
+      vi.doUnmock('@ai-sdk/google');
     }
   });
 

package/src/__tests__/auth-and-toolcalling.test.ts

@@ -521,16 +521,66 @@ describe('streamChatWithTools', () => {
       events.push(event);
     }
 
-    // Should have tool-call event followed by text-delta + finish (no double call)
+    // Should have tool-call + tool-result events followed by text-delta + finish
     const toolCallEvents = events.filter(e => e.type === 'tool-call');
     expect(toolCallEvents).toHaveLength(1);
     expect((toolCallEvents[0] as any).toolName).toBe('get_weather');
 
+    const toolResultEvents = events.filter(e => e.type === 'tool-result');
+    expect(toolResultEvents).toHaveLength(1);
+    expect((toolResultEvents[0] as any).toolCallId).toBe('call_1');
+    expect((toolResultEvents[0] as any).toolName).toBe('get_weather');
+
     const finishEvent = events.find(e => e.type === 'finish');
     expect(finishEvent).toBeDefined();
     expect(adapter.chat).toHaveBeenCalledTimes(2);
   });
 
+  it('should yield tool-result events with tool output', async () => {
+    const toolCall: ToolCallPart = {
+      type: 'tool-call',
+      toolCallId: 'call_weather',
+      toolName: 'get_weather',
+      input: { city: 'Paris' },
+    };
+
+    let chatCallIndex = 0;
+    const adapter: LLMAdapter = {
+      name: 'mock-stream',
+      chat: vi.fn(async () => {
+        chatCallIndex++;
+        if (chatCallIndex === 1) {
+          return { content: '', toolCalls: [toolCall] };
+        }
+        return { content: 'Paris is 22°C' };
+      }),
+      complete: vi.fn(async () => ({ content: '' })),
+    };
+
+    const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
+    const events: TextStreamPart<ToolSet>[] = [];
+    for await (const event of service.streamChatWithTools(
+      [{ role: 'user', content: 'Weather in Paris?' }],
+    )) {
+      events.push(event);
+    }
+
+    // Verify the tool-result contains actual tool output
+    const toolResultEvents = events.filter(e => e.type === 'tool-result');
+    expect(toolResultEvents).toHaveLength(1);
+    const toolResult = toolResultEvents[0] as any;
+    expect(toolResult.toolCallId).toBe('call_weather');
+    expect(toolResult.toolName).toBe('get_weather');
+    expect(toolResult.output).toEqual({ type: 'text', value: JSON.stringify({ temp: 22, city: 'Paris' }) });
+
+    // Verify order: tool-call comes before tool-result
+    const toolCallIdx = events.findIndex(e => e.type === 'tool-call');
+    const toolResultIdx = events.findIndex(e => e.type === 'tool-result');
+    expect(toolCallIdx).toBeGreaterThanOrEqual(0);
+    expect(toolResultIdx).toBeGreaterThanOrEqual(0);
+    expect(toolCallIdx).toBeLessThan(toolResultIdx);
+  });
+
   it('should fall back to non-streaming when adapter has no streamChat', async () => {
     const adapter: LLMAdapter = {
       name: 'no-stream',

package/src/__tests__/chatbot-features.test.ts

@@ -304,15 +304,13 @@ describe('AIService.chatWithTools', () => {
 
 describe('Data Tools', () => {
   describe('DATA_TOOL_DEFINITIONS', () => {
-    it('should define exactly 5 tools', () => {
-      expect(DATA_TOOL_DEFINITIONS).toHaveLength(5);
+    it('should define exactly 3 tools', () => {
+      expect(DATA_TOOL_DEFINITIONS).toHaveLength(3);
     });
 
     it('should include all expected tool names', () => {
       const names = DATA_TOOL_DEFINITIONS.map(t => t.name);
       expect(names).toEqual([
-        'list_objects',
-        'describe_object',
         'query_records',
         'get_record',
         'aggregate_data',
@@ -336,22 +334,24 @@ describe('Data Tools', () => {
       registry = new ToolRegistry();
       dataEngine = createMockDataEngine();
       metadataService = createMockMetadataService();
-      registerDataTools(registry, { dataEngine, metadataService });
+      registerDataTools(registry, { dataEngine });
     });
 
-    it('should register all 5 tools', () => {
-      expect(registry.size).toBe(5);
-      expect(registry.has('list_objects')).toBe(true);
-      expect(registry.has('describe_object')).toBe(true);
+    it('should register all 3 tools', () => {
+      expect(registry.size).toBe(3);
       expect(registry.has('query_records')).toBe(true);
       expect(registry.has('get_record')).toBe(true);
       expect(registry.has('aggregate_data')).toBe(true);
     });
 
-    it('list_objects should return object names and labels', async () => {
+    it('list_objects should return object names and labels (via metadata tools)', async () => {
+      // list_objects is now part of metadata tools — register them
+      const { registerMetadataTools } = await import('../tools/metadata-tools.js');
+      registerMetadataTools(registry, { metadataService });
+
       (metadataService.listObjects as any).mockResolvedValue([
-        { name: 'account', label: 'Account' },
-        { name: 'contact', label: 'Contact' },
+        { name: 'account', label: 'Account', fields: { name: { type: 'text' } } },
+        { name: 'contact', label: 'Contact', fields: {} },
       ]);
 
       const result = await registry.execute({
@@ -362,11 +362,15 @@ describe('Data Tools', () => {
       });
 
       const parsed = JSON.parse((result.output as any).value);
-      expect(parsed).toHaveLength(2);
-      expect(parsed[0]).toEqual({ name: 'account', label: 'Account' });
+      expect(parsed.objects).toHaveLength(2);
+      expect(parsed.objects[0]).toEqual(expect.objectContaining({ name: 'account', label: 'Account' }));
     });
 
-    it('describe_object should return field schema', async () => {
+    it('describe_object should return field schema (via metadata tools)', async () => {
+      // describe_object is now part of metadata tools — register them
+      const { registerMetadataTools } = await import('../tools/metadata-tools.js');
+      registerMetadataTools(registry, { metadataService });
+
       (metadataService.getObject as any).mockResolvedValue({
         name: 'account',
         label: 'Account',
@@ -385,12 +389,19 @@ describe('Data Tools', () => {
 
       const parsed = JSON.parse((result.output as any).value);
       expect(parsed.name).toBe('account');
-      expect(parsed.fields.name.type).toBe('text');
-      expect(parsed.fields.name.required).toBe(true);
-      expect(parsed.fields.revenue.type).toBe('number');
+      // Unified handler returns fields as array (not object)
+      const nameField = parsed.fields.find((f: any) => f.name === 'name');
+      expect(nameField.type).toBe('text');
+      expect(nameField.required).toBe(true);
+      const revenueField = parsed.fields.find((f: any) => f.name === 'revenue');
+      expect(revenueField.type).toBe('number');
     });
 
-    it('describe_object should return error for unknown object', async () => {
+    it('describe_object should return error for unknown object (via metadata tools)', async () => {
+      // describe_object is now part of metadata tools — register them
+      const { registerMetadataTools } = await import('../tools/metadata-tools.js');
+      registerMetadataTools(registry, { metadataService });
+
       const result = await registry.execute({
         type: 'tool-call' as const,
         toolCallId: 'c1',
@@ -807,13 +818,14 @@ describe('Agent Routes', () => {
     expect((resp.body as any).error).toContain('not active');
   });
 
-  it('should return 200 with agent response for valid request', async () => {
+  it('should return 200 with agent response for valid request (stream=false)', async () => {
     const chatRoute = routes.find(r => r.method === 'POST')!;
     const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'user', content: 'List all tables' }],
         context: { objectName: 'account' },
+        stream: false,
       },
     });
     expect(resp.status).toBe(200);
@@ -862,6 +874,7 @@ describe('Agent Routes', () => {
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'user', content: 'test' }],
+        stream: false,
         options: {
           tools: [{ name: 'injected_tool', description: 'Evil', parameters: {} }],
           toolChoice: 'injected_tool',
@@ -874,6 +887,141 @@ describe('Agent Routes', () => {
     // temperature is a safe key, should be passed through
     // tools/toolChoice/model should NOT be passed through
   });
+
+  // ── Vercel AI SDK v6 `parts` format support ──
+
+  it('should accept Vercel AI SDK v6 parts format messages', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        stream: false,
+        messages: [
+          {
+            role: 'user',
+            parts: [{ type: 'text', text: 'List all tables' }],
+          },
+        ],
+      },
+    });
+    expect(resp.status).toBe(200);
+    expect((resp.body as any).content).toBe('Agent response');
+  });
+
+  it('should accept mixed parts and content messages', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        stream: false,
+        messages: [
+          { role: 'user', content: 'Hello' },
+          {
+            role: 'assistant',
+            parts: [{ type: 'text', text: 'Hi there' }],
+          },
+          {
+            role: 'user',
+            parts: [{ type: 'text', text: 'List objects' }],
+          },
+        ],
+      },
+    });
+    expect(resp.status).toBe(200);
+  });
+
+  it('should accept assistant message with parts and no content', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        stream: false,
+        messages: [
+          {
+            role: 'assistant',
+            parts: [{ type: 'text', text: 'previous response' }],
+          },
+          {
+            role: 'user',
+            parts: [{ type: 'text', text: 'follow up' }],
+          },
+        ],
+      },
+    });
+    expect(resp.status).toBe(200);
+  });
+
+  it('should reject user message with neither content nor parts', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        messages: [{ role: 'user' }],
+      },
+    });
+    expect(resp.status).toBe(400);
+    expect((resp.body as any).error).toContain('content');
+  });
+
+  // ── Vercel Data Stream Protocol (SSE) ──
+
+  it('should default to Vercel Data Stream mode when stream is not specified', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        messages: [{ role: 'user', content: 'List all tables' }],
+      },
+    });
+    expect(resp.status).toBe(200);
+    expect(resp.stream).toBe(true);
+    expect(resp.vercelDataStream).toBe(true);
+    expect(resp.events).toBeDefined();
+
+    // Consume the Vercel Data Stream events
+    const events: unknown[] = [];
+    for await (const event of resp.events!) {
+      events.push(event);
+    }
+    expect(events.length).toBeGreaterThan(0);
+    // Must contain standard SSE lifecycle events
+    const eventsStr = events.join('');
+    expect(eventsStr).toContain('"type":"start"');
+    expect(eventsStr).toContain('"type":"text-delta"');
+    expect(eventsStr).toContain('"type":"finish"');
+    expect(eventsStr).toContain('data: [DONE]');
+  });
+
+  it('should return Vercel Data Stream when stream=true explicitly', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        messages: [{ role: 'user', content: 'Hello agent' }],
+        stream: true,
+      },
+    });
+    expect(resp.status).toBe(200);
+    expect(resp.stream).toBe(true);
+    expect(resp.vercelDataStream).toBe(true);
+    expect(resp.events).toBeDefined();
+  });
+
+  it('should return JSON when stream=false', async () => {
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
+      params: { agentName: 'data_chat' },
+      body: {
+        messages: [{ role: 'user', content: 'Hello agent' }],
+        stream: false,
+      },
+    });
+    expect(resp.status).toBe(200);
+    expect(resp.stream).toBeUndefined();
+    expect(resp.vercelDataStream).toBeUndefined();
+    expect(resp.body).toBeDefined();
+    expect((resp.body as any).content).toBeDefined();
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -930,8 +1078,8 @@ describe('METADATA_ASSISTANT_AGENT', () => {
     expect(toolNames).toContain('add_field');
     expect(toolNames).toContain('modify_field');
     expect(toolNames).toContain('delete_field');
-    expect(toolNames).toContain('list_metadata_objects');
-    expect(toolNames).toContain('describe_metadata_object');
+    expect(toolNames).toContain('list_objects');
+    expect(toolNames).toContain('describe_object');
   });
 
   it('should use action type for mutation tools and query type for read tools', () => {
@@ -962,7 +1110,7 @@ describe('METADATA_ASSISTANT_AGENT', () => {
   it('should have instructions mentioning metadata management capabilities', () => {
     const instructions = METADATA_ASSISTANT_AGENT.instructions;
     expect(instructions).toContain('snake_case');
-    expect(instructions).toContain('list_metadata_objects');
-    expect(instructions).toContain('describe_metadata_object');
+    expect(instructions).toContain('list_objects');
+    expect(instructions).toContain('describe_object');
   });
 });

package/src/__tests__/metadata-tools.test.ts

@@ -17,8 +17,8 @@ import { createObjectTool } from '../tools/create-object.tool.js';
 import { addFieldTool } from '../tools/add-field.tool.js';
 import { modifyFieldTool } from '../tools/modify-field.tool.js';
 import { deleteFieldTool } from '../tools/delete-field.tool.js';
-import { listMetadataObjectsTool } from '../tools/list-metadata-objects.tool.js';
-import { describeMetadataObjectTool } from '../tools/describe-metadata-object.tool.js';
+import { listObjectsTool } from '../tools/list-objects.tool.js';
+import { describeObjectTool } from '../tools/describe-object.tool.js';
 
 // ── Helpers ────────────────────────────────────────────────────────
 
@@ -63,8 +63,8 @@ describe('Metadata Tool Definitions', () => {
       'add_field',
       'modify_field',
       'delete_field',
-      'list_metadata_objects',
-      'describe_metadata_object',
+      'list_objects',
+      'describe_object',
     ]);
   });
 
@@ -86,8 +86,8 @@ describe('Individual Tool Metadata (.tool.ts)', () => {
     { tool: addFieldTool, expectedName: 'add_field', expectedLabel: 'Add Field' },
     { tool: modifyFieldTool, expectedName: 'modify_field', expectedLabel: 'Modify Field' },
     { tool: deleteFieldTool, expectedName: 'delete_field', expectedLabel: 'Delete Field' },
-    { tool: listMetadataObjectsTool, expectedName: 'list_metadata_objects', expectedLabel: 'List Metadata Objects' },
-    { tool: describeMetadataObjectTool, expectedName: 'describe_metadata_object', expectedLabel: 'Describe Metadata Object' },
+    { tool: listObjectsTool, expectedName: 'list_objects', expectedLabel: 'List Objects' },
+    { tool: describeObjectTool, expectedName: 'describe_object', expectedLabel: 'Describe Object' },
   ];
 
   for (const { tool, expectedName, expectedLabel } of tools) {
@@ -132,8 +132,8 @@ describe('Individual Tool Metadata (.tool.ts)', () => {
   });
 
   it('should not mark read-only tools as requiresConfirmation', () => {
-    expect(listMetadataObjectsTool.requiresConfirmation).toBe(false);
-    expect(describeMetadataObjectTool.requiresConfirmation).toBe(false);
+    expect(listObjectsTool.requiresConfirmation).toBe(false);
+    expect(describeObjectTool.requiresConfirmation).toBe(false);
   });
 
   it('should not mark add_field and modify_field as requiresConfirmation', () => {
@@ -162,8 +162,8 @@ describe('registerMetadataTools', () => {
     expect(registry.has('add_field')).toBe(true);
     expect(registry.has('modify_field')).toBe(true);
     expect(registry.has('delete_field')).toBe(true);
-    expect(registry.has('list_metadata_objects')).toBe(true);
-    expect(registry.has('describe_metadata_object')).toBe(true);
+    expect(registry.has('list_objects')).toBe(true);
+    expect(registry.has('describe_object')).toBe(true);
   });
 });
 
@@ -171,8 +171,8 @@ describe('registerMetadataTools', () => {
 // Dual registration (data tools + metadata tools)
 // ═══════════════════════════════════════════════════════════════════
 
-describe('registerDataTools + registerMetadataTools — no collision', () => {
-  it('should register both tool sets on the same registry without overwriting', () => {
+describe('registerDataTools + registerMetadataTools — unified list/describe', () => {
+  it('should register both tool sets on the same registry with shared list_objects and describe_object', () => {
     const registry = new ToolRegistry();
     const metadataService = createMockMetadataService();
     const dataEngine = {
@@ -181,26 +181,32 @@ describe('registerDataTools + registerMetadataTools — no collision', () => {
       aggregate: vi.fn(),
     } as any;
 
-    registerDataTools(registry, { dataEngine, metadataService });
+    registerDataTools(registry, { dataEngine });
     const sizeAfterData = registry.size;
 
     registerMetadataTools(registry, { metadataService });
     const sizeAfterBoth = registry.size;
 
-    // Data tools define: list_objects, describe_object, query_records, get_record, aggregate_data
-    // Metadata tools define: create_object, add_field, modify_field, delete_field, list_metadata_objects, describe_metadata_object
-    // No overlap — total should be sum of both
+    // Data tools define: query_records, get_record, aggregate_data (3)
+    // Metadata tools define: create_object, add_field, modify_field, delete_field, list_objects, describe_object (6)
+    // Total should be 3 + 6 = 9
+    expect(sizeAfterData).toBe(3);
     expect(sizeAfterBoth).toBe(sizeAfterData + 6);
 
-    // Data tools should still be present
+    // Unified list/describe should be present (from metadata tools)
     expect(registry.has('list_objects')).toBe(true);
     expect(registry.has('describe_object')).toBe(true);
+
+    // Data-only tools should be present
     expect(registry.has('query_records')).toBe(true);
+    expect(registry.has('get_record')).toBe(true);
+    expect(registry.has('aggregate_data')).toBe(true);
 
-    // Metadata tools should also be present with distinct names
-    expect(registry.has('list_metadata_objects')).toBe(true);
-    expect(registry.has('describe_metadata_object')).toBe(true);
+    // Metadata-only tools should be present
     expect(registry.has('create_object')).toBe(true);
+    expect(registry.has('add_field')).toBe(true);
+    expect(registry.has('modify_field')).toBe(true);
+    expect(registry.has('delete_field')).toBe(true);
   });
 });
 
@@ -752,7 +758,7 @@ describe('list_metadata_objects handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c1',
-      toolName: 'list_metadata_objects',
+      toolName: 'list_objects',
       input: {},
     });
 
@@ -767,7 +773,7 @@ describe('list_metadata_objects handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c2',
-      toolName: 'list_metadata_objects',
+      toolName: 'list_objects',
       input: { filter: 'account' },
     });
 
@@ -780,7 +786,7 @@ describe('list_metadata_objects handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c3',
-      toolName: 'list_metadata_objects',
+      toolName: 'list_objects',
       input: { includeFields: true },
     });
 
@@ -797,7 +803,7 @@ describe('list_metadata_objects handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c4',
-      toolName: 'list_metadata_objects',
+      toolName: 'list_objects',
       input: {},
     });
 
@@ -836,7 +842,7 @@ describe('describe_metadata_object handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c1',
-      toolName: 'describe_metadata_object',
+      toolName: 'describe_object',
       input: { objectName: 'account' },
     });
 
@@ -858,7 +864,7 @@ describe('describe_metadata_object handler', () => {
     const result = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 'c2',
-      toolName: 'describe_metadata_object',
+      toolName: 'describe_object',
       input: { objectName: 'nonexistent' },
     });
 
@@ -909,7 +915,7 @@ describe('Metadata Tools — full lifecycle', () => {
     const descResult = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 's4',
-      toolName: 'describe_metadata_object',
+      toolName: 'describe_object',
       input: { objectName: 'invoice' },
     });
     const desc = JSON.parse((descResult.output as any).value);
@@ -941,7 +947,7 @@ describe('Metadata Tools — full lifecycle', () => {
     const descResult2 = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 's7',
-      toolName: 'describe_metadata_object',
+      toolName: 'describe_object',
       input: { objectName: 'invoice' },
     });
     const desc2 = JSON.parse((descResult2.output as any).value);
@@ -954,7 +960,7 @@ describe('Metadata Tools — full lifecycle', () => {
     const listResult = await registry.execute({
       type: 'tool-call' as const,
       toolCallId: 's8',
-      toolName: 'list_metadata_objects',
+      toolName: 'list_objects',
       input: {},
     });
     const list = JSON.parse((listResult.output as any).value);