@objectstack/service-ai 4.0.1 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/service-ai",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "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",
@@ -14,11 +14,33 @@
     }
   },
   "dependencies": {
-    "@objectstack/core": "4.0.1",
-    "@objectstack/spec": "4.0.1"
+    "@ai-sdk/provider": "^3.0.8",
+    "ai": "^6.0.146",
+    "@objectstack/core": "4.0.2",
+    "@objectstack/spec": "4.0.2"
+  },
+  "peerDependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/gateway": "^3.0.0",
+    "@ai-sdk/google": "^3.0.0",
+    "@ai-sdk/openai": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/gateway": {
+      "optional": true
+    },
+    "@ai-sdk/google": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.5.2",
     "typescript": "^6.0.2",
     "vitest": "^4.1.2"
   },

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

@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { AIMessage, IAIService, AIStreamEvent } from '@objectstack/spec/contracts';
+import type { ModelMessage, IAIService, TextStreamPart, ToolSet } from '@objectstack/spec/contracts';
 import { AIService } from '../ai-service.js';
 import { MemoryLLMAdapter } from '../adapters/memory-adapter.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
@@ -35,7 +35,7 @@ describe('MemoryLLMAdapter', () => {
   });
 
   it('should echo the last user message in chat()', async () => {
-    const messages: AIMessage[] = [
+    const messages: ModelMessage[] = [
       { role: 'system', content: 'You are helpful.' },
       { role: 'user', content: 'Hello AI' },
     ];
@@ -46,7 +46,7 @@ describe('MemoryLLMAdapter', () => {
   });
 
   it('should handle no user message in chat()', async () => {
-    const messages: AIMessage[] = [{ role: 'system', content: 'System only' }];
+    const messages: ModelMessage[] = [{ role: 'system', content: 'System only' }];
     const result = await adapter.chat(messages);
     expect(result.content).toBe('[memory] (no user message)');
   });
@@ -57,8 +57,8 @@ describe('MemoryLLMAdapter', () => {
   });
 
   it('should stream word-by-word in streamChat()', async () => {
-    const messages: AIMessage[] = [{ role: 'user', content: 'Hi there' }];
-    const events: AIStreamEvent[] = [];
+    const messages: ModelMessage[] = [{ role: 'user', content: 'Hi there' }];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of adapter.streamChat(messages)) {
       events.push(event);
     }
@@ -113,24 +113,26 @@ describe('ToolRegistry', () => {
     );
 
     const result = await registry.execute({
-      id: 'call_1',
-      name: 'add',
-      arguments: JSON.stringify({ a: 3, b: 4 }),
+      type: 'tool-call',
+      toolCallId: 'call_1',
+      toolName: 'add',
+      input: { a: 3, b: 4 },
     });
 
     expect(result.toolCallId).toBe('call_1');
-    expect(result.content).toBe('7');
+    expect(result.output).toEqual({ type: 'text', value: '7' });
     expect(result.isError).toBeUndefined();
   });
 
   it('should return error for unknown tool', async () => {
     const result = await registry.execute({
-      id: 'call_x',
-      name: 'unknown',
-      arguments: '{}',
+      type: 'tool-call',
+      toolCallId: 'call_x',
+      toolName: 'unknown',
+      input: {},
     });
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('not registered');
+    expect(result.output).toEqual(expect.objectContaining({ type: 'text', value: expect.stringContaining('not registered') }));
   });
 
   it('should return error on handler failure', async () => {
@@ -140,12 +142,13 @@ describe('ToolRegistry', () => {
     );
 
     const result = await registry.execute({
-      id: 'call_f',
-      name: 'fail_tool',
-      arguments: '{}',
+      type: 'tool-call',
+      toolCallId: 'call_f',
+      toolName: 'fail_tool',
+      input: {},
     });
     expect(result.isError).toBe(true);
-    expect(result.content).toBe('boom');
+    expect(result.output).toEqual({ type: 'text', value: 'boom' });
   });
 
   it('should execute multiple tool calls in parallel', async () => {
@@ -155,13 +158,13 @@ describe('ToolRegistry', () => {
     );
 
     const results = await registry.executeAll([
-      { id: 'c1', name: 'echo', arguments: '{"msg":"a"}' },
-      { id: 'c2', name: 'echo', arguments: '{"msg":"b"}' },
+      { type: 'tool-call', toolCallId: 'c1', toolName: 'echo', input: { msg: 'a' } },
+      { type: 'tool-call', toolCallId: 'c2', toolName: 'echo', input: { msg: 'b' } },
     ]);
 
     expect(results).toHaveLength(2);
-    expect(results[0].content).toBe('a');
-    expect(results[1].content).toBe('b');
+    expect(results[0].output).toEqual({ type: 'text', value: 'a' });
+    expect(results[1].output).toEqual({ type: 'text', value: 'b' });
   });
 
   it('should return all definitions', () => {
@@ -272,7 +275,7 @@ describe('AIService', () => {
 
   it('should stream via adapter.streamChat()', async () => {
     const service = new AIService({ logger: silentLogger });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChat([{ role: 'user', content: 'Hi' }])) {
       events.push(event);
     }
@@ -289,14 +292,14 @@ describe('AIService', () => {
     };
     const service = new AIService({ adapter, logger: silentLogger });
 
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChat([{ role: 'user', content: 'Hi' }])) {
       events.push(event);
     }
 
     expect(events).toHaveLength(2);
     expect(events[0].type).toBe('text-delta');
-    expect(events[0].textDelta).toBe('response');
+    expect(events[0].type === 'text-delta' && events[0].text).toBe('response');
     expect(events[1].type).toBe('finish');
   });
 
@@ -379,7 +382,19 @@ describe('AI Routes', () => {
     expect(paths).toContain('DELETE /api/v1/ai/conversations/:id');
   });
 
-  it('POST /api/v1/ai/chat should return chat result', async () => {
+  it('POST /api/v1/ai/chat should return JSON result when stream=false', async () => {
+    const routes = buildAIRoutes(service, service.conversationService, silentLogger);
+    const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
+
+    const response = await chatRoute.handler({
+      body: { messages: [{ role: 'user', content: 'Hi' }], stream: false },
+    });
+
+    expect(response.status).toBe(200);
+    expect((response.body as any).content).toBe('[memory] Hi');
+  });
+
+  it('POST /api/v1/ai/chat should default to Vercel Data Stream mode', async () => {
     const routes = buildAIRoutes(service, service.conversationService, silentLogger);
     const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
 
@@ -387,10 +402,86 @@ describe('AI Routes', () => {
       body: { messages: [{ role: 'user', content: 'Hi' }] },
     });
 
+    expect(response.status).toBe(200);
+    expect(response.stream).toBe(true);
+    expect(response.vercelDataStream).toBe(true);
+    expect(response.events).toBeDefined();
+
+    // Consume the Vercel Data Stream events
+    const events: unknown[] = [];
+    for await (const event of response.events!) {
+      events.push(event);
+    }
+    expect(events.length).toBeGreaterThan(0);
+  });
+
+  it('POST /api/v1/ai/chat should prepend systemPrompt as system message', async () => {
+    const routes = buildAIRoutes(service, service.conversationService, silentLogger);
+    const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
+
+    const response = await chatRoute.handler({
+      body: {
+        messages: [{ role: 'user', content: 'Hello' }],
+        system: 'You are a helpful assistant',
+        stream: false,
+      },
+    });
+
+    expect(response.status).toBe(200);
+    // MemoryLLMAdapter echoes the last user message
+    expect((response.body as any).content).toBe('[memory] Hello');
+  });
+
+  it('POST /api/v1/ai/chat should accept deprecated systemPrompt field', async () => {
+    const routes = buildAIRoutes(service, service.conversationService, silentLogger);
+    const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
+
+    const response = await chatRoute.handler({
+      body: {
+        messages: [{ role: 'user', content: 'Hi' }],
+        systemPrompt: 'Be concise',
+        stream: false,
+      },
+    });
+
     expect(response.status).toBe(200);
     expect((response.body as any).content).toBe('[memory] Hi');
   });
 
+  it('POST /api/v1/ai/chat should accept flat Vercel-style fields (model, temperature)', async () => {
+    const routes = buildAIRoutes(service, service.conversationService, silentLogger);
+    const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
+
+    const response = await chatRoute.handler({
+      body: {
+        messages: [{ role: 'user', content: 'Hi' }],
+        model: 'gpt-4o',
+        temperature: 0.5,
+        stream: false,
+      },
+    });
+
+    expect(response.status).toBe(200);
+    // MemoryLLMAdapter uses the model from options when provided
+    expect((response.body as any).model).toBe('gpt-4o');
+  });
+
+  it('POST /api/v1/ai/chat should accept array content (Vercel multi-part)', async () => {
+    const routes = buildAIRoutes(service, service.conversationService, silentLogger);
+    const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
+
+    const response = await chatRoute.handler({
+      body: {
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hi' }] }],
+        stream: false,
+      },
+    });
+
+    // MemoryLLMAdapter falls back to "(complex content)" for non-string
+    expect(response.status).toBe(200);
+    expect((response.body as any).content).toBe('[memory] (complex content)');
+  });
+
   it('POST /api/v1/ai/chat should return 400 without messages', async () => {
     const routes = buildAIRoutes(service, service.conversationService, silentLogger);
     const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
@@ -528,16 +619,30 @@ describe('AI Routes', () => {
     expect((response.body as any).error).toContain('message.role');
   });
 
-  it('POST /api/v1/ai/chat should return 400 for messages with non-string content', async () => {
+  it('POST /api/v1/ai/chat should return 400 for messages with non-string/non-array content', async () => {
     const routes = buildAIRoutes(service, service.conversationService, silentLogger);
     const chatRoute = routes.find(r => r.path === '/api/v1/ai/chat')!;
 
+    // Numeric content should be rejected
     const response = await chatRoute.handler({
       body: { messages: [{ role: 'user', content: 123 }] },
     });
-
     expect(response.status).toBe(400);
     expect((response.body as any).error).toContain('content');
+
+    // Object content (not an array) should be rejected
+    const response2 = await chatRoute.handler({
+      body: { messages: [{ role: 'user', content: { nested: true } }] },
+    });
+    expect(response2.status).toBe(400);
+    expect((response2.body as any).error).toContain('content');
+
+    // Boolean content should be rejected
+    const response3 = await chatRoute.handler({
+      body: { messages: [{ role: 'user', content: true }] },
+    });
+    expect(response3.status).toBe(400);
+    expect((response3.body as any).error).toContain('content');
   });
 
   it('POST /api/v1/ai/conversations/:id/messages should return 400 for invalid role', async () => {
@@ -617,6 +722,7 @@ describe('AI Routes', () => {
           { role: 'assistant', content: '' },
           { role: 'tool', content: '{"temp": 22}', toolCallId: 'call_1' },
         ],
+        stream: false,
       },
     });
 
@@ -633,6 +739,9 @@ describe('AIServicePlugin', () => {
     const services = new Map<string, unknown>();
     const hooks = new Map<string, Function[]>();
 
+    // Pre-register manifest service
+    services.set('manifest', { register: vi.fn() });
+
     return {
       registerService: vi.fn((name: string, service: unknown) => services.set(name, service)),
       replaceService: vi.fn((name: string, service: unknown) => services.set(name, service)),
@@ -728,4 +837,116 @@ describe('AIServicePlugin', () => {
 
     expect(ctx.hook).toHaveBeenCalledWith('ai:beforeChat', expect.any(Function));
   });
+
+  // ── LLM Provider Auto-Detection ─────────────────────────────────
+
+  it('should use MemoryLLMAdapter when no env vars are set', async () => {
+    const plugin = new AIServicePlugin();
+    const ctx = createMockContext();
+
+    // Ensure no LLM provider env vars are set
+    const oldEnv = { ...process.env };
+    delete process.env.AI_GATEWAY_MODEL;
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+
+    try {
+      await plugin.init(ctx);
+
+      const service = ctx.getService<AIService>('ai');
+      expect(service.adapterName).toBe('memory');
+
+      // Verify warning was logged
+      expect(silentLogger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('No LLM provider configured')
+      );
+    } finally {
+      // Restore environment
+      process.env = oldEnv;
+    }
+  });
+
+  it('should fallback to MemoryLLMAdapter when provider SDK is not installed', async () => {
+    const plugin = new AIServicePlugin();
+    const ctx = createMockContext();
+
+    const oldEnv = { ...process.env };
+    // Set env var, but the SDK won't be available in test environment
+    process.env.OPENAI_API_KEY = 'fake-openai-key';
+    delete process.env.AI_GATEWAY_MODEL;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+
+    try {
+      await plugin.init(ctx);
+
+      const service = ctx.getService<AIService>('ai');
+      // Should fall back to memory because @ai-sdk/openai is not installed
+      expect(service.adapterName).toBe('memory');
+
+      // Verify warning was logged about SDK load failure
+      expect(silentLogger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load @ai-sdk/openai'),
+        expect.objectContaining({ error: expect.any(String) })
+      );
+
+      // Verify warning was logged about final fallback
+      expect(silentLogger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('No LLM provider configured')
+      );
+    } finally {
+      process.env = oldEnv;
+    }
+  });
+
+  it('should prefer explicit adapter over auto-detection', async () => {
+    const customAdapter: LLMAdapter = {
+      name: 'custom-explicit',
+      chat: async () => ({ content: 'explicit' }),
+      complete: async () => ({ content: '' }),
+    };
+
+    const plugin = new AIServicePlugin({ adapter: customAdapter });
+    const ctx = createMockContext();
+
+    const oldEnv = { ...process.env };
+    process.env.OPENAI_API_KEY = 'fake-openai-key';
+
+    try {
+      await plugin.init(ctx);
+
+      const service = ctx.getService<AIService>('ai');
+      expect(service.adapterName).toBe('custom-explicit');
+
+      // Verify it logged as explicitly configured
+      expect(silentLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('explicitly configured')
+      );
+    } finally {
+      process.env = oldEnv;
+    }
+  });
+
+  it('should log adapter selection', async () => {
+    const plugin = new AIServicePlugin();
+    const ctx = createMockContext();
+
+    const oldEnv = { ...process.env };
+    delete process.env.AI_GATEWAY_MODEL;
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+
+    try {
+      await plugin.init(ctx);
+
+      // Verify adapter selection was logged
+      expect(silentLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Using LLM adapter')
+      );
+    } finally {
+      process.env = oldEnv;
+    }
+  });
 });

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

@@ -2,11 +2,12 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import type {
-  AIMessage,
+  ModelMessage,
   AIResult,
   AIRequestOptions,
-  AIStreamEvent,
-  AIToolCall,
+  TextStreamPart,
+  ToolSet,
+  ToolCallPart,
   LLMAdapter,
 } from '@objectstack/spec/contracts';
 import { AIService } from '../ai-service.js';
@@ -313,7 +314,7 @@ describe('chatWithTools — Enhanced Error Handling', () => {
 
     const onToolError = vi.fn().mockReturnValue('continue');
     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: 'Recovered' },
     ]);
 
@@ -325,7 +326,7 @@ describe('chatWithTools — Enhanced Error Handling', () => {
 
     expect(onToolError).toHaveBeenCalledTimes(1);
     expect(onToolError).toHaveBeenCalledWith(
-      expect.objectContaining({ name: 'bad_tool' }),
+      expect.objectContaining({ toolName: 'bad_tool' }),
       'boom',
     );
     expect(result.content).toBe('Recovered');
@@ -338,7 +339,7 @@ describe('chatWithTools — Enhanced Error Handling', () => {
     );
 
     const adapter = createMockAdapter([
-      { content: '', toolCalls: [{ id: 'c1', name: 'abort_tool', arguments: '{}' }] },
+      { content: '', toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c1', toolName: 'abort_tool', input: {} }] },
       // This would be the forced-final call
       { content: 'Aborted cleanly' },
     ]);
@@ -381,7 +382,7 @@ describe('chatWithTools — Enhanced Error Handling', () => {
     );
 
     const adapter = createMockAdapter([
-      { content: '', toolCalls: [{ id: 'c1', name: 'fail_tool', arguments: '{}' }] },
+      { content: '', toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c1', toolName: 'fail_tool', input: {} }] },
       { content: 'Error was fed back to model' },
     ]);
 
@@ -400,7 +401,7 @@ describe('chatWithTools — Enhanced Error Handling', () => {
 
     const infiniteToolCall: AIResult = {
       content: '',
-      toolCalls: [{ id: 'c', name: 'flaky_tool', arguments: '{}' }],
+      toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c', toolName: 'flaky_tool', input: {} }],
     };
     const adapter = createMockAdapter(
       Array(2).fill(infiniteToolCall).concat([{ content: 'Forced' }]),
@@ -430,8 +431,8 @@ describe('chatWithTools — Enhanced Error Handling', () => {
       {
         content: '',
         toolCalls: [
-          { id: 'c1', name: 'get_weather', arguments: '{"city":"NYC"}' },
-          { id: 'c2', name: 'bad_tool', arguments: '{}' },
+          { type: 'tool-call' as const, toolCallId: 'c1', toolName: 'get_weather', input: { city: 'NYC' } },
+          { type: 'tool-call' as const, toolCallId: 'c2', toolName: 'bad_tool', input: {} },
         ],
       },
       { content: 'Weather ok, tool failed' },
@@ -447,12 +448,12 @@ describe('chatWithTools — Enhanced Error Handling', () => {
     // Only called for the failing tool
     expect(onToolError).toHaveBeenCalledTimes(1);
     expect(onToolError).toHaveBeenCalledWith(
-      expect.objectContaining({ name: 'bad_tool' }),
+      expect.objectContaining({ toolName: 'bad_tool' }),
       'fail',
     );
 
     // Both tool results fed back
-    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);
     expect(result.content).toBe('Weather ok, tool failed');
@@ -478,7 +479,7 @@ describe('streamChatWithTools', () => {
     };
 
     const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChatWithTools([{ role: 'user', content: 'Hi' }])) {
       events.push(event);
     }
@@ -486,16 +487,17 @@ describe('streamChatWithTools', () => {
     // Should emit the probed result as text-delta + finish (no double model call)
     expect(events).toHaveLength(2);
     expect(events[0].type).toBe('text-delta');
-    expect(events[0].textDelta).toBe('Hello!');
+    expect((events[0] as any).text).toBe('Hello!');
     expect(events[1].type).toBe('finish');
     expect(adapter.chat).toHaveBeenCalledTimes(1);
   });
 
   it('should emit tool-call events during tool resolution', async () => {
-    const toolCall: AIToolCall = {
-      id: 'call_1',
-      name: 'get_weather',
-      arguments: JSON.stringify({ city: 'Tokyo' }),
+    const toolCall: ToolCallPart = {
+      type: 'tool-call',
+      toolCallId: 'call_1',
+      toolName: 'get_weather',
+      input: { city: 'Tokyo' },
     };
 
     let chatCallIndex = 0;
@@ -512,7 +514,7 @@ describe('streamChatWithTools', () => {
     };
 
     const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChatWithTools(
       [{ role: 'user', content: 'Weather in Tokyo?' }],
     )) {
@@ -522,7 +524,7 @@ describe('streamChatWithTools', () => {
     // Should have tool-call event followed by text-delta + finish (no double call)
     const toolCallEvents = events.filter(e => e.type === 'tool-call');
     expect(toolCallEvents).toHaveLength(1);
-    expect(toolCallEvents[0].toolCall?.name).toBe('get_weather');
+    expect((toolCallEvents[0] as any).toolName).toBe('get_weather');
 
     const finishEvent = events.find(e => e.type === 'finish');
     expect(finishEvent).toBeDefined();
@@ -539,7 +541,7 @@ describe('streamChatWithTools', () => {
 
     const emptyRegistry = new ToolRegistry();
     const service = new AIService({ adapter, logger: silentLogger, toolRegistry: emptyRegistry });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChatWithTools(
       [{ role: 'user', content: 'Hi' }],
     )) {
@@ -548,14 +550,14 @@ describe('streamChatWithTools', () => {
 
     expect(events).toHaveLength(2);
     expect(events[0].type).toBe('text-delta');
-    expect(events[0].textDelta).toBe('Fallback response');
+    expect((events[0] as any).text).toBe('Fallback response');
     expect(events[1].type).toBe('finish');
   });
 
   it('should respect maxIterations in streaming tool loop', async () => {
     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' } }],
     };
 
     let callIndex = 0;
@@ -568,13 +570,13 @@ describe('streamChatWithTools', () => {
       }),
       complete: vi.fn(async () => ({ content: '' })),
       async *streamChat() {
-        yield { type: 'text-delta' as const, textDelta: 'Forced stop' };
-        yield { type: 'finish' as const, result: { content: 'Forced stop' } };
+        yield { type: 'text-delta' as const, id: '1', text: 'Forced stop' } as TextStreamPart<ToolSet>;
+        yield { type: 'finish' as const, finishReason: 'stop' as const, totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }, rawFinishReason: 'stop' } as unknown as TextStreamPart<ToolSet>;
       },
     };
 
     const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChatWithTools(
       [{ role: 'user', content: 'Loop' }],
       { maxIterations: 2 },
@@ -601,7 +603,7 @@ describe('streamChatWithTools', () => {
         if (chatCallIndex === 1) {
           return {
             content: '',
-            toolCalls: [{ id: 'c1', name: 'critical_fail', arguments: '{}' }],
+            toolCalls: [{ type: 'tool-call' as const, toolCallId: 'c1', toolName: 'critical_fail', input: {} }],
           };
         }
         return { content: 'Aborted' };
@@ -610,7 +612,7 @@ describe('streamChatWithTools', () => {
     };
 
     const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
-    const events: AIStreamEvent[] = [];
+    const events: TextStreamPart<ToolSet>[] = [];
     for await (const event of service.streamChatWithTools(
       [{ role: 'user', content: 'Critical' }],
       { onToolError: () => 'abort' },