@objectstack/service-ai 4.0.0 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/service-ai",
-  "version": "4.0.0",
+  "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.0",
-    "@objectstack/spec": "4.0.0"
+    "@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;
+    }
+  });
 });