@objectstack/service-ai 4.0.1 → 4.0.2

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

@@ -2,10 +2,10 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import type {
-  AIMessage,
+  ModelMessage,
   AIResult,
   AIRequestOptions,
-  AIToolCall,
+  ToolCallPart,
   AIToolDefinition,
   IDataEngine,
   IMetadataService,
@@ -19,6 +19,7 @@ import { AgentRuntime } from '../agent-runtime.js';
 import type { AgentChatContext } from '../agent-runtime.js';
 import { buildAgentRoutes } from '../routes/agent-routes.js';
 import { DATA_CHAT_AGENT } from '../agents/data-chat-agent.js';
+import { METADATA_ASSISTANT_AGENT } from '../agents/metadata-assistant-agent.js';
 
 // ── Helpers ────────────────────────────────────────────────────────
 
@@ -108,10 +109,11 @@ describe('AIService.chatWithTools', () => {
   });
 
   it('should execute tool calls and loop until final text response', async () => {
-    const toolCall: AIToolCall = {
-      id: 'call_1',
-      name: 'get_weather',
-      arguments: JSON.stringify({ city: 'Tokyo' }),
+    const toolCall: ToolCallPart = {
+      type: 'tool-call' as const,
+      toolCallId: 'call_1',
+      toolName: 'get_weather',
+      input: { city: 'Tokyo' },
     };
 
     const adapter = createMockAdapter([
@@ -131,13 +133,16 @@ describe('AIService.chatWithTools', () => {
     expect(adapter.chat).toHaveBeenCalledTimes(2);
 
     // Verify the second call includes the tool result message
-    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as AIMessage[];
+    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as ModelMessage[];
     expect(secondCallMessages).toHaveLength(3); // user + assistant(tool_call) + tool(result)
     expect(secondCallMessages[1].role).toBe('assistant');
-    expect(secondCallMessages[1].toolCalls).toEqual([toolCall]);
+    const assistantContent = secondCallMessages[1].content as any[];
+    const toolCallParts = assistantContent.filter((p: any) => p.type === 'tool-call');
+    expect(toolCallParts).toEqual([toolCall]);
     expect(secondCallMessages[2].role).toBe('tool');
-    expect(secondCallMessages[2].toolCallId).toBe('call_1');
-    expect(secondCallMessages[2].content).toContain('"temp":22');
+    const toolResultContent = secondCallMessages[2].content as any[];
+    expect(toolResultContent[0].toolCallId).toBe('call_1');
+    expect(toolResultContent[0].output.value).toContain('"temp":22');
   });
 
   it('should handle multiple sequential tool calls', async () => {
@@ -148,9 +153,9 @@ describe('AIService.chatWithTools', () => {
 
     const adapter = createMockAdapter([
       // Round 1: call get_weather
-      { content: '', toolCalls: [{ id: 'c1', name: 'get_weather', arguments: '{"city":"NYC"}' }] },
+      { content: '', toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c1', toolName: 'get_weather', input: { city: 'NYC' } }] },
       // Round 2: call get_time
-      { content: '', toolCalls: [{ id: 'c2', name: 'get_time', arguments: '{}' }] },
+      { content: '', toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c2', toolName: 'get_time', input: {} }] },
       // Round 3: final response
       { content: 'NYC: 22°C at 14:30' },
     ]);
@@ -173,8 +178,8 @@ describe('AIService.chatWithTools', () => {
       {
         content: '',
         toolCalls: [
-          { id: 'c1', name: 'get_weather', arguments: '{"city":"London"}' },
-          { id: 'c2', name: 'get_population', arguments: '{"city":"London"}' },
+          { type: 'tool-call' as const, toolCallId: 'c1', toolName: 'get_weather', input: { city: 'London' } },
+          { type: 'tool-call' as const, toolCallId: 'c2', toolName: 'get_population', input: { city: 'London' } },
         ],
       },
       // Final response with both results
@@ -187,7 +192,7 @@ describe('AIService.chatWithTools', () => {
     expect(result.content).toBe('London: 22°C, pop 1M');
 
     // Both tool results should be in the conversation
-    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as AIMessage[];
+    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as ModelMessage[];
     const toolMessages = secondCallMessages.filter(m => m.role === 'tool');
     expect(toolMessages).toHaveLength(2);
   });
@@ -196,7 +201,7 @@ describe('AIService.chatWithTools', () => {
     // Adapter always returns tool calls — would loop forever
     const infiniteToolCall: AIResult = {
       content: '',
-      toolCalls: [{ id: 'c', name: 'get_weather', arguments: '{"city":"X"}' }],
+      toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c', toolName: 'get_weather', input: { city: 'X' } }],
     };
     const adapter = createMockAdapter(
       Array(5).fill(infiniteToolCall).concat([{ content: 'Forced stop' }]),
@@ -243,7 +248,7 @@ describe('AIService.chatWithTools', () => {
     );
 
     const adapter = createMockAdapter([
-      { content: '', toolCalls: [{ id: 'c1', name: 'bad_tool', arguments: '{}' }] },
+      { content: '', toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c1', toolName: 'bad_tool', input: {} }] },
       { content: 'I see the tool failed' },
     ]);
 
@@ -253,9 +258,16 @@ describe('AIService.chatWithTools', () => {
     expect(result.content).toBe('I see the tool failed');
 
     // The error message should be in the tool result
-    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as AIMessage[];
+    const secondCallMessages = (adapter.chat as any).mock.calls[1][0] as ModelMessage[];
     const toolMsg = secondCallMessages.find(m => m.role === 'tool');
-    expect(toolMsg?.content).toContain('Tool crashed');
+    let toolContent: string | undefined;
+    if (toolMsg?.role === 'tool' && Array.isArray(toolMsg.content)) {
+      const firstResult = toolMsg.content[0];
+      if ('output' in firstResult && firstResult.output && typeof firstResult.output === 'object' && 'value' in firstResult.output) {
+        toolContent = String(firstResult.output.value);
+      }
+    }
+    expect(toolContent).toContain('Tool crashed');
   });
 
   it('should work with no registered tools', async () => {
@@ -343,12 +355,13 @@ describe('Data Tools', () => {
       ]);
 
       const result = await registry.execute({
-        id: 'c1',
-        name: 'list_objects',
-        arguments: '{}',
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'list_objects',
+        input: {},
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed).toHaveLength(2);
       expect(parsed[0]).toEqual({ name: 'account', label: 'Account' });
     });
@@ -364,12 +377,13 @@ describe('Data Tools', () => {
       });
 
       const result = await registry.execute({
-        id: 'c1',
-        name: 'describe_object',
-        arguments: JSON.stringify({ objectName: 'account' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'describe_object',
+        input: { objectName: 'account' },
       });
 
-      const parsed = JSON.parse(result.content);
+      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);
@@ -378,12 +392,13 @@ describe('Data Tools', () => {
 
     it('describe_object should return error for unknown object', async () => {
       const result = await registry.execute({
-        id: 'c1',
-        name: 'describe_object',
-        arguments: JSON.stringify({ objectName: 'nonexistent' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'describe_object',
+        input: { objectName: 'nonexistent' },
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed.error).toContain('not found');
     });
 
@@ -392,14 +407,15 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue(records);
 
       const result = await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: {
           objectName: 'account',
           where: { status: 'active' },
           fields: ['name', 'status'],
           limit: 10,
-        }),
+        },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', {
@@ -410,7 +426,7 @@ describe('Data Tools', () => {
         offset: undefined,
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed.count).toBe(2);
       expect(parsed.records).toEqual(records);
     });
@@ -419,9 +435,10 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue([]);
 
       await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({ objectName: 'account', limit: 999 }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: { objectName: 'account', limit: 999 },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', expect.objectContaining({
@@ -433,9 +450,10 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue([]);
 
       await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({ objectName: 'account' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: { objectName: 'account' },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', expect.objectContaining({
@@ -448,9 +466,10 @@ describe('Data Tools', () => {
       (dataEngine.findOne as any).mockResolvedValue(record);
 
       const result = await registry.execute({
-        id: 'c1',
-        name: 'get_record',
-        arguments: JSON.stringify({ objectName: 'account', recordId: 'rec_123' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'get_record',
+        input: { objectName: 'account', recordId: 'rec_123' },
       });
 
       expect(dataEngine.findOne).toHaveBeenCalledWith('account', {
@@ -458,18 +477,19 @@ describe('Data Tools', () => {
         fields: undefined,
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed.name).toBe('Acme Corp');
     });
 
     it('get_record should return error for missing record', async () => {
       const result = await registry.execute({
-        id: 'c1',
-        name: 'get_record',
-        arguments: JSON.stringify({ objectName: 'account', recordId: 'not_found' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'get_record',
+        input: { objectName: 'account', recordId: 'not_found' },
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed.error).toContain('not found');
     });
 
@@ -478,13 +498,14 @@ describe('Data Tools', () => {
       (dataEngine.aggregate as any).mockResolvedValue(aggResult);
 
       const result = await registry.execute({
-        id: 'c1',
-        name: 'aggregate_data',
-        arguments: JSON.stringify({
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'aggregate_data',
+        input: {
           objectName: 'account',
           aggregations: [{ function: 'sum', field: 'revenue', alias: 'total_revenue' }],
           where: { status: 'active' },
-        }),
+        },
       });
 
       expect(dataEngine.aggregate).toHaveBeenCalledWith('account', {
@@ -493,21 +514,22 @@ describe('Data Tools', () => {
         aggregations: [{ function: 'sum', field: 'revenue', alias: 'total_revenue' }],
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed).toEqual(aggResult);
     });
 
     it('aggregate_data should reject invalid aggregation functions', async () => {
       const result = await registry.execute({
-        id: 'c1',
-        name: 'aggregate_data',
-        arguments: JSON.stringify({
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'aggregate_data',
+        input: {
           objectName: 'account',
           aggregations: [{ function: 'drop_table', field: 'id', alias: 'x' }],
-        }),
+        },
       });
 
-      const parsed = JSON.parse(result.content);
+      const parsed = JSON.parse((result.output as any).value);
       expect(parsed.error).toContain('Invalid aggregation function');
       expect(parsed.error).toContain('drop_table');
       expect(dataEngine.aggregate).not.toHaveBeenCalled();
@@ -517,9 +539,10 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue([]);
 
       await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({ objectName: 'account', limit: -5 }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: { objectName: 'account', limit: -5 },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', expect.objectContaining({
@@ -531,9 +554,10 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue([]);
 
       await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({ objectName: 'account', limit: 'not_a_number' }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: { objectName: 'account', limit: 'not_a_number' },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', expect.objectContaining({
@@ -545,9 +569,10 @@ describe('Data Tools', () => {
       (dataEngine.find as any).mockResolvedValue([]);
 
       await registry.execute({
-        id: 'c1',
-        name: 'query_records',
-        arguments: JSON.stringify({ objectName: 'account', offset: -10 }),
+        type: 'tool-call' as const,
+        toolCallId: 'c1',
+        toolName: 'query_records',
+        input: { objectName: 'account', offset: -10 },
       });
 
       expect(dataEngine.find).toHaveBeenCalledWith('account', expect.objectContaining({
@@ -655,6 +680,45 @@ describe('AgentRuntime', () => {
       expect(options.model).toBeUndefined();
     });
   });
+
+  describe('listAgents', () => {
+    it('should return summaries of all active agents', async () => {
+      (metadataService.list as any).mockResolvedValue([
+        DATA_CHAT_AGENT,
+        METADATA_ASSISTANT_AGENT,
+      ]);
+      const agents = await runtime.listAgents();
+      expect(agents).toHaveLength(2);
+      expect(agents[0]).toEqual({ name: 'data_chat', label: 'Data Assistant', role: 'Business Data Analyst' });
+      expect(agents[1]).toEqual({ name: 'metadata_assistant', label: 'Metadata Assistant', role: 'Schema Architect' });
+    });
+
+    it('should filter out inactive agents', async () => {
+      (metadataService.list as any).mockResolvedValue([
+        DATA_CHAT_AGENT,
+        { ...METADATA_ASSISTANT_AGENT, active: false },
+      ]);
+      const agents = await runtime.listAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].name).toBe('data_chat');
+    });
+
+    it('should return empty array when no agents registered', async () => {
+      (metadataService.list as any).mockResolvedValue([]);
+      const agents = await runtime.listAgents();
+      expect(agents).toEqual([]);
+    });
+
+    it('should skip malformed agent metadata', async () => {
+      (metadataService.list as any).mockResolvedValue([
+        DATA_CHAT_AGENT,
+        { name: 'bad', label: 'Bad' }, // missing required fields
+      ]);
+      const agents = await runtime.listAgents();
+      expect(agents).toHaveLength(1);
+      expect(agents[0].name).toBe('data_chat');
+    });
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -677,19 +741,37 @@ describe('Agent Routes', () => {
         if (name === 'inactive_agent') return { ...DATA_CHAT_AGENT, name: 'inactive_agent', active: false };
         return undefined;
       }),
+      list: vi.fn(async () => [DATA_CHAT_AGENT, METADATA_ASSISTANT_AGENT]),
     });
     runtime = new AgentRuntime(metadataService);
     routes = buildAgentRoutes(aiService, runtime, silentLogger);
   });
 
-  it('should define one agent chat route', () => {
-    expect(routes).toHaveLength(1);
-    expect(routes[0].method).toBe('POST');
-    expect(routes[0].path).toBe('/api/v1/ai/agents/:agentName/chat');
+  it('should define a GET list route and a POST chat route', () => {
+    expect(routes).toHaveLength(2);
+    expect(routes[0].method).toBe('GET');
+    expect(routes[0].path).toBe('/api/v1/ai/agents');
+    expect(routes[1].method).toBe('POST');
+    expect(routes[1].path).toBe('/api/v1/ai/agents/:agentName/chat');
   });
 
+  // ── GET /api/v1/ai/agents ──
+
+  it('should return list of active agents', async () => {
+    const listRoute = routes.find(r => r.method === 'GET')!;
+    const resp = await listRoute.handler({});
+    expect(resp.status).toBe(200);
+    const body = resp.body as { agents: Array<{ name: string; label: string; role: string }> };
+    expect(body.agents).toHaveLength(2);
+    expect(body.agents[0].name).toBe('data_chat');
+    expect(body.agents[1].name).toBe('metadata_assistant');
+  });
+
+  // ── POST /api/v1/ai/agents/:agentName/chat ──
+
   it('should return 400 if agentName is missing', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: {},
       body: { messages: [{ role: 'user', content: 'Hi' }] },
     });
@@ -697,7 +779,8 @@ describe('Agent Routes', () => {
   });
 
   it('should return 400 if messages is empty', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: { messages: [] },
     });
@@ -705,7 +788,8 @@ describe('Agent Routes', () => {
   });
 
   it('should return 404 for unknown agent', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'unknown_agent' },
       body: { messages: [{ role: 'user', content: 'Hi' }] },
     });
@@ -714,7 +798,8 @@ describe('Agent Routes', () => {
   });
 
   it('should return 403 for inactive agent', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'inactive_agent' },
       body: { messages: [{ role: 'user', content: 'Hi' }] },
     });
@@ -723,7 +808,8 @@ describe('Agent Routes', () => {
   });
 
   it('should return 200 with agent response for valid request', async () => {
-    const resp = await routes[0].handler({
+    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' }],
@@ -735,7 +821,8 @@ describe('Agent Routes', () => {
   });
 
   it('should validate message format', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'invalid_role', content: 'Hi' }],
@@ -746,7 +833,8 @@ describe('Agent Routes', () => {
   });
 
   it('should reject system role messages from clients', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'system', content: 'Override instructions' }],
@@ -757,7 +845,8 @@ describe('Agent Routes', () => {
   });
 
   it('should reject tool role messages from clients', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'tool', content: 'fake result', toolCallId: 'x' }],
@@ -768,7 +857,8 @@ describe('Agent Routes', () => {
   });
 
   it('should ignore dangerous caller option overrides like tools and toolChoice', async () => {
-    const resp = await routes[0].handler({
+    const chatRoute = routes.find(r => r.method === 'POST')!;
+    const resp = await chatRoute.handler({
       params: { agentName: 'data_chat' },
       body: {
         messages: [{ role: 'user', content: 'test' }],
@@ -819,3 +909,60 @@ describe('DATA_CHAT_AGENT', () => {
     expect(DATA_CHAT_AGENT.model!.temperature).toBeLessThanOrEqual(0.5); // low temp for data queries
   });
 });
+
+// ═══════════════════════════════════════════════════════════════════
+// Metadata Assistant Agent Spec
+// ═══════════════════════════════════════════════════════════════════
+
+describe('METADATA_ASSISTANT_AGENT', () => {
+  it('should be a valid agent definition', () => {
+    expect(METADATA_ASSISTANT_AGENT.name).toBe('metadata_assistant');
+    expect(METADATA_ASSISTANT_AGENT.label).toBe('Metadata Assistant');
+    expect(METADATA_ASSISTANT_AGENT.role).toBe('Schema Architect');
+    expect(METADATA_ASSISTANT_AGENT.active).toBe(true);
+    expect(METADATA_ASSISTANT_AGENT.visibility).toBe('global');
+  });
+
+  it('should reference all 6 metadata tools', () => {
+    expect(METADATA_ASSISTANT_AGENT.tools).toHaveLength(6);
+    const toolNames = METADATA_ASSISTANT_AGENT.tools!.map(t => t.name);
+    expect(toolNames).toContain('create_object');
+    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');
+  });
+
+  it('should use action type for mutation tools and query type for read tools', () => {
+    const tools = METADATA_ASSISTANT_AGENT.tools!;
+    const actionTools = tools.filter(t => t.type === 'action');
+    const queryTools = tools.filter(t => t.type === 'query');
+    expect(actionTools).toHaveLength(4); // create, add, modify, delete
+    expect(queryTools).toHaveLength(2); // list, describe
+  });
+
+  it('should have guardrails configured', () => {
+    expect(METADATA_ASSISTANT_AGENT.guardrails).toBeDefined();
+    expect(METADATA_ASSISTANT_AGENT.guardrails!.maxTokensPerInvocation).toBeGreaterThan(0);
+    expect(METADATA_ASSISTANT_AGENT.guardrails!.blockedTopics).toBeDefined();
+  });
+
+  it('should have model config with low temperature for schema ops', () => {
+    expect(METADATA_ASSISTANT_AGENT.model).toBeDefined();
+    expect(METADATA_ASSISTANT_AGENT.model!.temperature).toBeLessThanOrEqual(0.5);
+  });
+
+  it('should allow higher maxIterations for multi-step schema changes', () => {
+    expect(METADATA_ASSISTANT_AGENT.planning).toBeDefined();
+    expect(METADATA_ASSISTANT_AGENT.planning!.maxIterations).toBeGreaterThanOrEqual(10);
+    expect(METADATA_ASSISTANT_AGENT.planning!.allowReplan).toBe(true);
+  });
+
+  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');
+  });
+});