@objectstack/service-ai 4.0.1 → 4.0.3

package/src/__tests__/objectql-conversation-service.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import type { IDataEngine } from '@objectstack/spec/contracts';
-import type { AIMessage } from '@objectstack/spec/contracts';
+import type { ModelMessage } from '@objectstack/spec/contracts';
 import { ObjectQLConversationService } from '../conversation/objectql-conversation-service.js';
 
 // ─────────────────────────────────────────────────────────────────
@@ -242,7 +242,7 @@ describe('ObjectQLConversationService', () => {
   it('should add a user message to a conversation', async () => {
     const conv = await service.create({ title: 'Chat' });
 
-    const msg: AIMessage = { role: 'user', content: 'Hello AI!' };
+    const msg: ModelMessage = { role: 'user', content: 'Hello AI!' };
     const updated = await service.addMessage(conv.id, msg);
 
     expect(updated.messages).toHaveLength(1);
@@ -253,33 +253,49 @@ describe('ObjectQLConversationService', () => {
 
   it('should add a tool message with toolCallId', async () => {
     const conv = await service.create();
-    const msg: AIMessage = {
-      role: 'tool',
-      content: '{"temp": 22}',
-      toolCallId: 'call_abc',
+    const msg: ModelMessage = {
+      role: 'tool' as const,
+      content: [{
+        type: 'tool-result' as const,
+        toolCallId: 'call_abc',
+        toolName: 'get_weather',
+        output: { type: 'text' as const, value: '{"temp": 22}' },
+      }],
     };
 
     const updated = await service.addMessage(conv.id, msg);
     expect(updated.messages).toHaveLength(1);
-    expect(updated.messages[0].toolCallId).toBe('call_abc');
+    const firstMsg = updated.messages[0];
+    if (firstMsg.role === 'tool' && Array.isArray(firstMsg.content)) {
+      expect(firstMsg.content[0].toolCallId).toBe('call_abc');
+    } else {
+      throw new Error('Expected tool message with array content');
+    }
   });
 
   it('should add an assistant message with toolCalls', async () => {
     const conv = await service.create();
-    const msg: AIMessage = {
-      role: 'assistant',
-      content: '',
-      toolCalls: [{ id: 'call_1', name: 'get_weather', arguments: '{}' }],
+    const msg: ModelMessage = {
+      role: 'assistant' as const,
+      content: [
+        { type: 'tool-call' as const, toolCallId: 'call_1', toolName: 'get_weather', input: {} },
+      ],
     };
 
     const updated = await service.addMessage(conv.id, msg);
     expect(updated.messages).toHaveLength(1);
-    expect(updated.messages[0].toolCalls).toHaveLength(1);
-    expect(updated.messages[0].toolCalls![0].name).toBe('get_weather');
+    const firstMsg = updated.messages[0];
+    if (firstMsg.role === 'assistant' && Array.isArray(firstMsg.content)) {
+      const toolCallParts = firstMsg.content.filter((p) => p.type === 'tool-call');
+      expect(toolCallParts).toHaveLength(1);
+      expect(toolCallParts[0].toolName).toBe('get_weather');
+    } else {
+      throw new Error('Expected assistant message with array content');
+    }
   });
 
   it('should throw when adding message to non-existent conversation', async () => {
-    const msg: AIMessage = { role: 'user', content: 'Hello' };
+    const msg: ModelMessage = { role: 'user', content: 'Hello' };
     await expect(service.addMessage('conv_ghost', msg)).rejects.toThrow(
       'Conversation "conv_ghost" not found',
     );
@@ -352,13 +368,15 @@ describe('ObjectQLConversationService', () => {
 
   it('should handle invalid JSON in tool_calls gracefully', async () => {
     const conv = await service.create();
-    await service.addMessage(conv.id, { role: 'user', content: 'hi' });
+    await service.addMessage(conv.id, { role: 'assistant', content: 'checking tools' });
 
     // Manually corrupt tool_calls in the engine
     const msgs = await engine.find('ai_messages', { where: { conversation_id: conv.id } });
     msgs[0].tool_calls = 'broken{json';
 
     const fetched = await service.get(conv.id);
-    expect(fetched!.messages[0].toolCalls).toBeUndefined();
+    // With broken tool_calls, the assistant message should still load with string content
+    expect(fetched!.messages[0].role).toBe('assistant');
+    expect(fetched!.messages[0].content).toBe('checking tools');
   });
 });

package/src/__tests__/tool-routes.test.ts

@@ -0,0 +1,191 @@
+// 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'],
+        },
+      },
+      async (params: any) => {
+        return JSON.stringify({ 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');
+      // 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');
+    });
+
+    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: {} },
+        },
+        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);
+      });
+    });
+  });
+});

package/src/__tests__/vercel-stream-encoder.test.ts

@@ -0,0 +1,310 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect } from 'vitest';
+import type { TextStreamPart, ToolSet } from '@objectstack/spec/contracts';
+import { encodeStreamPart, encodeVercelDataStream } from '../stream/vercel-stream-encoder.js';
+
+// Helper to parse SSE frame payload
+function parseSSE(frame: string): Record<string, unknown> | null {
+  if (!frame.startsWith('data: ') || !frame.endsWith('\n\n')) return null;
+  const json = frame.slice(6, -2);
+  if (json === '[DONE]') return null;
+  return JSON.parse(json);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// encodeStreamPart — individual frame encoding (v6 SSE format)
+// ─────────────────────────────────────────────────────────────────
+
+describe('encodeStreamPart', () => {
+  it('should encode text-delta as SSE frame', () => {
+    const part = { type: 'text-delta', text: 'Hello world' } as TextStreamPart<ToolSet>;
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({ type: 'text-delta', id: '0', delta: 'Hello world' });
+  });
+
+  it('should JSON-escape text-delta content', () => {
+    const part = { type: 'text-delta', text: 'say "hi"\nnewline' } as TextStreamPart<ToolSet>;
+    const frame = encodeStreamPart(part);
+    expect(frame.startsWith('data: ')).toBe(true);
+    expect(frame.endsWith('\n\n')).toBe(true);
+
+    // Verify round-trip: decode the frame payload back to the original text
+    const payload = parseSSE(frame);
+    expect(payload).not.toBeNull();
+    expect((payload as Record<string, unknown>).delta).toBe('say "hi"\nnewline');
+  });
+
+  it('should encode tool-call as tool-input-available SSE frame', () => {
+    const part = {
+      type: 'tool-call',
+      toolCallId: 'call_1',
+      toolName: 'get_weather',
+      input: { location: 'San Francisco' },
+    } as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({
+      type: 'tool-input-available',
+      toolCallId: 'call_1',
+      toolName: 'get_weather',
+      input: { location: 'San Francisco' },
+    });
+  });
+
+  it('should encode tool-input-start as SSE frame', () => {
+    const part = {
+      type: 'tool-input-start',
+      id: 'call_2',
+      toolName: 'search',
+    } as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({
+      type: 'tool-input-start',
+      toolCallId: 'call_2',
+      toolName: 'search',
+    });
+  });
+
+  it('should encode tool-input-delta as SSE frame', () => {
+    const part = {
+      type: 'tool-input-delta',
+      id: 'call_2',
+      delta: '{"query":',
+    } as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({
+      type: 'tool-input-delta',
+      toolCallId: 'call_2',
+      inputTextDelta: '{"query":',
+    });
+  });
+
+  it('should encode tool-result as tool-output-available SSE frame', () => {
+    const part = {
+      type: 'tool-result',
+      toolCallId: 'call_1',
+      toolName: 'get_weather',
+      output: { temperature: 72 },
+    } as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({
+      type: 'tool-output-available',
+      toolCallId: 'call_1',
+      output: { temperature: 72 },
+    });
+  });
+
+  it('should return empty string for finish (handled by generator)', () => {
+    const part = {
+      type: 'finish',
+      finishReason: 'stop',
+      totalUsage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+      rawFinishReason: 'stop',
+    } as unknown as TextStreamPart<ToolSet>;
+
+    expect(encodeStreamPart(part)).toBe('');
+  });
+
+  it('should return empty string for finish-step (handled by generator)', () => {
+    const part = {
+      type: 'finish-step',
+      finishReason: 'tool-calls',
+      usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
+    } as unknown as TextStreamPart<ToolSet>;
+
+    expect(encodeStreamPart(part)).toBe('');
+  });
+
+  it('should return empty string for unknown event types', () => {
+    const part = { type: 'unknown-internal' } as unknown as TextStreamPart<ToolSet>;
+    expect(encodeStreamPart(part)).toBe('');
+  });
+
+  it('should encode reasoning-start part with g: prefix', () => {
+    const part = {
+      type: 'reasoning-start',
+      id: 'r1',
+    } as unknown as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    expect(frame).toBe('g:{"text":""}\n');
+  });
+
+  it('should encode reasoning-delta part with g: prefix', () => {
+    const part = {
+      type: 'reasoning-delta',
+      id: 'r1',
+      text: 'Let me think through this step by step...',
+    } as unknown as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    expect(frame).toBe('g:{"text":"Let me think through this step by step..."}\n');
+  });
+
+  it('should encode reasoning-end part as empty (no specific end marker)', () => {
+    const part = {
+      type: 'reasoning-end',
+      id: 'r1',
+    } as unknown as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    expect(frame).toBe('');
+  });
+
+  it('should pass through custom step events', () => {
+    const part = {
+      type: 'step-start',
+      stepId: 'step_1',
+      stepName: 'Query database',
+    } as unknown as TextStreamPart<ToolSet>;
+
+    const frame = encodeStreamPart(part);
+    const payload = parseSSE(frame);
+    expect(payload).toEqual({
+      type: 'step-start',
+      stepId: 'step_1',
+      stepName: 'Query database',
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────
+// encodeVercelDataStream — async iterable transformation (v6 SSE)
+//
+// Lifecycle: start → start-step → text-start → ...events... → text-end → finish-step → finish → [DONE]
+// ─────────────────────────────────────────────────────────────────
+
+describe('encodeVercelDataStream', () => {
+  it('should transform stream events into v6 UI Message Stream frames', async () => {
+    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
+      yield { type: 'text-delta', text: 'Hello' } as TextStreamPart<ToolSet>;
+      yield { type: 'text-delta', text: ' world' } as TextStreamPart<ToolSet>;
+      yield {
+        type: 'finish',
+        finishReason: 'stop',
+        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        rawFinishReason: 'stop',
+      } as unknown as TextStreamPart<ToolSet>;
+    }
+
+    const frames: string[] = [];
+    for await (const frame of encodeVercelDataStream(source())) {
+      frames.push(frame);
+    }
+
+    // Preamble: start, start-step, text-start
+    // Content: 2 text-deltas
+    // Postamble: text-end, finish-step, finish, [DONE]
+    expect(frames).toHaveLength(9);
+
+    // Preamble
+    expect(parseSSE(frames[0])).toEqual({ type: 'start' });
+    expect(parseSSE(frames[1])).toEqual({ type: 'start-step' });
+    expect(parseSSE(frames[2])).toEqual({ type: 'text-start', id: '0' });
+
+    // Content
+    expect(parseSSE(frames[3])).toMatchObject({ type: 'text-delta', delta: 'Hello' });
+    expect(parseSSE(frames[4])).toMatchObject({ type: 'text-delta', delta: ' world' });
+
+    // Postamble
+    expect(parseSSE(frames[5])).toEqual({ type: 'text-end', id: '0' });
+    expect(parseSSE(frames[6])).toEqual({ type: 'finish-step' });
+    expect(parseSSE(frames[7])).toMatchObject({ type: 'finish', finishReason: 'stop' });
+    expect(frames[8]).toBe('data: [DONE]\n\n');
+  });
+
+  it('should skip events with no wire format mapping', async () => {
+    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
+      yield { type: 'text-delta', text: 'Hi' } as TextStreamPart<ToolSet>;
+      yield { type: 'unknown-internal' } as unknown as TextStreamPart<ToolSet>;
+      yield {
+        type: 'finish',
+        finishReason: 'stop',
+        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        rawFinishReason: 'stop',
+      } as unknown as TextStreamPart<ToolSet>;
+    }
+
+    const frames: string[] = [];
+    for await (const frame of encodeVercelDataStream(source())) {
+      frames.push(frame);
+    }
+
+    // Preamble(3) + 1 text-delta + Postamble(4) = 8 ('unknown-internal' dropped)
+    expect(frames).toHaveLength(8);
+    expect(parseSSE(frames[3])).toMatchObject({ type: 'text-delta', delta: 'Hi' });
+  });
+
+  it('should handle empty stream', async () => {
+    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
+      // empty
+    }
+
+    const frames: string[] = [];
+    for await (const frame of encodeVercelDataStream(source())) {
+      frames.push(frame);
+    }
+
+    // Preamble(3) + text-end + finish-step + finish + [DONE] = 7
+    expect(frames).toHaveLength(7);
+    expect(parseSSE(frames[0])).toEqual({ type: 'start' });
+    expect(parseSSE(frames[3])).toEqual({ type: 'text-end', id: '0' });
+    expect(frames[6]).toBe('data: [DONE]\n\n');
+  });
+
+  it('should handle tool-call events in stream', async () => {
+    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
+      yield {
+        type: 'tool-call',
+        toolCallId: 'call_1',
+        toolName: 'search',
+        input: { query: 'test' },
+      } as TextStreamPart<ToolSet>;
+      yield {
+        type: 'tool-result',
+        toolCallId: 'call_1',
+        toolName: 'search',
+        output: { hits: 42 },
+      } as TextStreamPart<ToolSet>;
+      yield {
+        type: 'finish',
+        finishReason: 'tool-calls',
+        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        rawFinishReason: 'tool_calls',
+      } as unknown as TextStreamPart<ToolSet>;
+    }
+
+    const frames: string[] = [];
+    for await (const frame of encodeVercelDataStream(source())) {
+      frames.push(frame);
+    }
+
+    // Preamble(3) + tool-input-available + tool-output-available + Postamble(4) = 9
+    expect(frames).toHaveLength(9);
+
+    // Verify tool-call frame content
+    const toolCallPayload = parseSSE(frames[3]);
+    expect(toolCallPayload).toMatchObject({
+      type: 'tool-input-available',
+      toolCallId: 'call_1',
+      toolName: 'search',
+      input: { query: 'test' },
+    });
+
+    const toolResultPayload = parseSSE(frames[4]);
+    expect(toolResultPayload).toMatchObject({
+      type: 'tool-output-available',
+      toolCallId: 'call_1',
+      output: { hits: 42 },
+    });
+  });
+});

package/src/adapters/index.ts

@@ -2,3 +2,5 @@
 
 export type { LLMAdapter } from '@objectstack/spec/contracts';
 export { MemoryLLMAdapter } from './memory-adapter.js';
+export { VercelLLMAdapter } from './vercel-adapter.js';
+export type { VercelLLMAdapterConfig } from './vercel-adapter.js';

package/src/adapters/memory-adapter.ts

@@ -1,10 +1,11 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import type {
-  AIMessage,
+  ModelMessage,
   AIRequestOptions,
   AIResult,
-  AIStreamEvent,
+  TextStreamPart,
+  ToolSet,
 } from '@objectstack/spec/contracts';
 import type { LLMAdapter } from '@objectstack/spec/contracts';
 
@@ -17,10 +18,12 @@ import type { LLMAdapter } from '@objectstack/spec/contracts';
 export class MemoryLLMAdapter implements LLMAdapter {
   readonly name = 'memory';
 
-  async chat(messages: AIMessage[], options?: AIRequestOptions): Promise<AIResult> {
+  async chat(messages: ModelMessage[], options?: AIRequestOptions): Promise<AIResult> {
     const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
+    const userContent = lastUserMessage?.content;
+    const text = typeof userContent === 'string' ? userContent : '(complex content)';
     const content = lastUserMessage
-      ? `[memory] ${lastUserMessage.content}`
+      ? `[memory] ${text}`
       : '[memory] (no user message)';
 
     return {
@@ -39,17 +42,22 @@ export class MemoryLLMAdapter implements LLMAdapter {
   }
 
   async *streamChat(
-    messages: AIMessage[],
+    messages: ModelMessage[],
     _options?: AIRequestOptions,
-  ): AsyncIterable<AIStreamEvent> {
+  ): AsyncIterable<TextStreamPart<ToolSet>> {
     const result = await this.chat(messages);
     // Emit word-by-word deltas for realistic streaming simulation
     const words = result.content.split(' ');
     for (let i = 0; i < words.length; i++) {
-      const textDelta = i === 0 ? words[i] : ` ${words[i]}`;
-      yield { type: 'text-delta', textDelta };
+      const wordText = i === 0 ? words[i] : ` ${words[i]}`;
+      yield { type: 'text-delta', id: `delta_${i}`, text: wordText } as TextStreamPart<ToolSet>;
     }
-    yield { type: 'finish', result };
+    yield {
+      type: 'finish',
+      finishReason: 'stop' as const,
+      totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      rawFinishReason: 'stop',
+    } as unknown as TextStreamPart<ToolSet>;
   }
 
   async embed(input: string | string[]): Promise<number[][]> {