@mohanscodex/spectra-ai 0.4.6 → 0.4.9

package/dist/__tests__/e2e.test.js

@@ -1,6 +1,6 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { EventStream, AssistantMessageEventStream } from "../event-stream.js";
-import { registerProvider, getProvider, stream, complete } from "../registry.js";
+import { describe, it, expect, beforeEach } from 'vitest';
+import { EventStream, AssistantMessageEventStream } from '../event-stream.js';
+import { registerProvider, getProvider, stream, complete } from '../registry.js';
 // Mock provider for testing (following pi-mono's provider pattern)
 function createMockProvider(name, responseEvents) {
     return {
@@ -19,70 +19,70 @@ function createMockProvider(name, responseEvents) {
     };
 }
 // Helper to create a complete assistant message
-function createAssistantMessage(text, stopReason = "stop") {
+function createAssistantMessage(text, stopReason = 'stop') {
     return {
-        role: "assistant",
-        content: [{ type: "text", text }],
-        provider: "test",
-        model: "test-model",
+        role: 'assistant',
+        content: [{ type: 'text', text }],
+        provider: 'test',
+        model: 'test-model',
         usage: { input: 10, output: 20, cacheRead: 0, cacheWrite: 0, totalTokens: 30 },
         stopReason,
         timestamp: Date.now(),
     };
 }
-describe("EventStream (pi-mono pattern)", () => {
-    it("should implement AsyncIterable interface", async () => {
-        const stream = new EventStream((e) => e === "end", (e) => e);
+describe('EventStream (pi-mono pattern)', () => {
+    it('should implement AsyncIterable interface', async () => {
+        const stream = new EventStream((e) => e === 'end', (e) => e);
         // Verify it's async iterable (pi-mono core pattern)
-        expect(typeof stream[Symbol.asyncIterator]).toBe("function");
+        expect(typeof stream[Symbol.asyncIterator]).toBe('function');
     });
-    it("should stream events in order (pi-mono push pattern)", async () => {
-        const stream = new EventStream((e) => e === "end", (e) => e);
-        stream.push("first");
-        stream.push("second");
-        stream.push("third");
-        stream.push("end");
+    it('should stream events in order (pi-mono push pattern)', async () => {
+        const stream = new EventStream((e) => e === 'end', (e) => e);
+        stream.push('first');
+        stream.push('second');
+        stream.push('third');
+        stream.push('end');
         const events = [];
         for await (const event of stream) {
             events.push(event);
         }
-        expect(events).toEqual(["first", "second", "third", "end"]);
+        expect(events).toEqual(['first', 'second', 'third', 'end']);
     });
-    it("should resolve result after completion", async () => {
-        const stream = new EventStream((e) => e === "done", (e) => e === "done" ? 42 : 0);
-        stream.push("working");
-        stream.push("done");
+    it('should resolve result after completion', async () => {
+        const stream = new EventStream((e) => e === 'done', (e) => (e === 'done' ? 42 : 0));
+        stream.push('working');
+        stream.push('done');
         stream.end();
         const result = await stream.result();
         expect(result).toBe(42);
     });
-    it("should handle single consumer pattern (pi-mono design)", async () => {
-        const stream = new EventStream((e) => e === "end", (e) => e);
-        stream.push("event1");
-        stream.push("event2");
-        stream.push("end");
+    it('should handle single consumer pattern (pi-mono design)', async () => {
+        const stream = new EventStream((e) => e === 'end', (e) => e);
+        stream.push('event1');
+        stream.push('event2');
+        stream.push('end');
         const events = [];
         for await (const e of stream) {
             events.push(e);
         }
-        expect(events).toEqual(["event1", "event2", "end"]);
+        expect(events).toEqual(['event1', 'event2', 'end']);
         // Note: EventStream is single-consumer by design (pi-mono pattern)
         // Multiple consumers would require a broadcast mechanism
     });
 });
-describe("AssistantMessageEventStream (pi-mono pattern)", () => {
-    it("should emit start, delta, and done events", async () => {
+describe('AssistantMessageEventStream (pi-mono pattern)', () => {
+    it('should emit start, delta, and done events', async () => {
         const stream = new AssistantMessageEventStream();
-        const partial = createAssistantMessage("");
-        stream.push({ type: "start", partial });
-        stream.push({ type: "text_start", contentIndex: 0, partial });
-        stream.push({ type: "text_delta", contentIndex: 0, delta: "Hello", partial });
-        stream.push({ type: "text_delta", contentIndex: 0, delta: " World", partial });
-        stream.push({ type: "text_end", contentIndex: 0, content: "Hello World", partial });
+        const partial = createAssistantMessage('');
+        stream.push({ type: 'start', partial });
+        stream.push({ type: 'text_start', contentIndex: 0, partial });
+        stream.push({ type: 'text_delta', contentIndex: 0, delta: 'Hello', partial });
+        stream.push({ type: 'text_delta', contentIndex: 0, delta: ' World', partial });
+        stream.push({ type: 'text_end', contentIndex: 0, content: 'Hello World', partial });
         stream.push({
-            type: "done",
-            reason: "stop",
-            message: createAssistantMessage("Hello World"),
+            type: 'done',
+            reason: 'stop',
+            message: createAssistantMessage('Hello World'),
         });
         stream.end();
         const events = [];
@@ -90,44 +90,44 @@ describe("AssistantMessageEventStream (pi-mono pattern)", () => {
             events.push(event);
         }
         expect(events).toHaveLength(6);
-        expect(events[0].type).toBe("start");
-        expect(events[1].type).toBe("text_start");
-        expect(events[2].type).toBe("text_delta");
-        expect(events[5].type).toBe("done");
+        expect(events[0].type).toBe('start');
+        expect(events[1].type).toBe('text_start');
+        expect(events[2].type).toBe('text_delta');
+        expect(events[5].type).toBe('done');
     });
-    it("should resolve to final AssistantMessage", async () => {
+    it('should resolve to final AssistantMessage', async () => {
         const stream = new AssistantMessageEventStream();
-        const finalMessage = createAssistantMessage("Final result");
-        stream.push({ type: "start", partial: createAssistantMessage("") });
-        stream.push({ type: "done", reason: "stop", message: finalMessage });
+        const finalMessage = createAssistantMessage('Final result');
+        stream.push({ type: 'start', partial: createAssistantMessage('') });
+        stream.push({ type: 'done', reason: 'stop', message: finalMessage });
         stream.end();
         const result = await stream.result();
-        expect(result.content[0]).toEqual({ type: "text", text: "Final result" });
-        expect(result.stopReason).toBe("stop");
+        expect(result.content[0]).toEqual({ type: 'text', text: 'Final result' });
+        expect(result.stopReason).toBe('stop');
     });
-    it("should handle error events", async () => {
+    it('should handle error events', async () => {
         const stream = new AssistantMessageEventStream();
-        const errorMessage = createAssistantMessage("");
-        errorMessage.stopReason = "error";
-        errorMessage.errorMessage = "Something went wrong";
-        stream.push({ type: "error", reason: "error", error: errorMessage });
+        const errorMessage = createAssistantMessage('');
+        errorMessage.stopReason = 'error';
+        errorMessage.errorMessage = 'Something went wrong';
+        stream.push({ type: 'error', reason: 'error', error: errorMessage });
         stream.end();
         const result = await stream.result();
-        expect(result.stopReason).toBe("error");
-        expect(result.errorMessage).toBe("Something went wrong");
+        expect(result.stopReason).toBe('error');
+        expect(result.errorMessage).toBe('Something went wrong');
     });
-    it("should handle thinking event streaming", async () => {
+    it('should handle thinking event streaming', async () => {
         const stream = new AssistantMessageEventStream();
-        const partial = createAssistantMessage("");
-        stream.push({ type: "start", partial });
-        stream.push({ type: "thinking_start", contentIndex: 0, partial });
-        stream.push({ type: "thinking_delta", contentIndex: 0, delta: "Let me", partial });
-        stream.push({ type: "thinking_delta", contentIndex: 0, delta: " think", partial });
-        stream.push({ type: "thinking_end", contentIndex: 0, content: "Let me think", partial });
+        const partial = createAssistantMessage('');
+        stream.push({ type: 'start', partial });
+        stream.push({ type: 'thinking_start', contentIndex: 0, partial });
+        stream.push({ type: 'thinking_delta', contentIndex: 0, delta: 'Let me', partial });
+        stream.push({ type: 'thinking_delta', contentIndex: 0, delta: ' think', partial });
+        stream.push({ type: 'thinking_end', contentIndex: 0, content: 'Let me think', partial });
         stream.push({
-            type: "done",
-            reason: "stop",
-            message: createAssistantMessage("Answer"),
+            type: 'done',
+            reason: 'stop',
+            message: createAssistantMessage('Answer'),
         });
         stream.end();
         const events = [];
@@ -135,55 +135,55 @@ describe("AssistantMessageEventStream (pi-mono pattern)", () => {
             events.push(event);
         }
         expect(events).toHaveLength(6);
-        const thinkingStart = events.find((e) => e.type === "thinking_start");
+        const thinkingStart = events.find((e) => e.type === 'thinking_start');
         expect(thinkingStart).toBeDefined();
-        const thinkingEnd = events.find((e) => e.type === "thinking_end");
+        const thinkingEnd = events.find((e) => e.type === 'thinking_end');
         expect(thinkingEnd).toBeDefined();
-        if (thinkingEnd?.type === "thinking_end") {
-            expect(thinkingEnd.content).toBe("Let me think");
+        if (thinkingEnd?.type === 'thinking_end') {
+            expect(thinkingEnd.content).toBe('Let me think');
         }
     });
-    it("should handle tool call streaming (pi-mono tool pattern)", async () => {
+    it('should handle tool call streaming (pi-mono tool pattern)', async () => {
         const stream = new AssistantMessageEventStream();
-        const partial = createAssistantMessage("");
-        stream.push({ type: "start", partial });
-        stream.push({ type: "toolcall_start", contentIndex: 0, partial });
-        stream.push({ type: "toolcall_delta", contentIndex: 0, delta: '{"lo', partial });
-        stream.push({ type: "toolcall_delta", contentIndex: 0, delta: 'cation":', partial });
-        stream.push({ type: "toolcall_delta", contentIndex: 0, delta: '"NYC"}', partial });
+        const partial = createAssistantMessage('');
+        stream.push({ type: 'start', partial });
+        stream.push({ type: 'toolcall_start', contentIndex: 0, partial });
+        stream.push({ type: 'toolcall_delta', contentIndex: 0, delta: '{"lo', partial });
+        stream.push({ type: 'toolcall_delta', contentIndex: 0, delta: 'cation":', partial });
+        stream.push({ type: 'toolcall_delta', contentIndex: 0, delta: '"NYC"}', partial });
         stream.push({
-            type: "toolcall_end",
+            type: 'toolcall_end',
             contentIndex: 0,
             toolCall: {
-                type: "toolCall",
-                id: "call_1",
-                name: "get_weather",
-                arguments: { location: "NYC" },
+                type: 'toolCall',
+                id: 'call_1',
+                name: 'get_weather',
+                arguments: { location: 'NYC' },
             },
             partial,
         });
         stream.push({
-            type: "done",
-            reason: "toolUse",
-            message: createAssistantMessage("", "toolUse"),
+            type: 'done',
+            reason: 'toolUse',
+            message: createAssistantMessage('', 'toolUse'),
         });
         stream.end();
         const events = [];
         for await (const event of stream) {
             events.push(event);
         }
-        const toolCallEnd = events.find((e) => e.type === "toolcall_end");
+        const toolCallEnd = events.find((e) => e.type === 'toolcall_end');
         expect(toolCallEnd).toBeDefined();
-        if (toolCallEnd?.type === "toolcall_end") {
-            expect(toolCallEnd.toolCall.name).toBe("get_weather");
-            expect(toolCallEnd.toolCall.arguments).toEqual({ location: "NYC" });
+        if (toolCallEnd?.type === 'toolcall_end') {
+            expect(toolCallEnd.toolCall.name).toBe('get_weather');
+            expect(toolCallEnd.toolCall.arguments).toEqual({ location: 'NYC' });
         }
     });
 });
-describe("Provider Registry (pi-mono provider pattern)", () => {
+describe('Provider Registry (pi-mono provider pattern)', () => {
     beforeEach(() => {
         // Clear registry
-        const providers = ["test-provider", "anthropic", "openai"];
+        const providers = ['test-provider', 'anthropic', 'openai'];
         for (const name of providers) {
             try {
                 // Re-register to ensure clean state
@@ -193,28 +193,28 @@ describe("Provider Registry (pi-mono provider pattern)", () => {
             }
         }
     });
-    it("should register and retrieve providers", () => {
-        const provider = createMockProvider("test-provider", []);
+    it('should register and retrieve providers', () => {
+        const provider = createMockProvider('test-provider', []);
         registerProvider(provider);
-        const retrieved = getProvider("test-provider");
+        const retrieved = getProvider('test-provider');
         expect(retrieved).toBeDefined();
-        expect(retrieved?.name).toBe("test-provider");
+        expect(retrieved?.name).toBe('test-provider');
     });
-    it("should stream through registered provider", async () => {
-        const mockMessage = createAssistantMessage("Hello from mock");
-        const provider = createMockProvider("mock-ai", [
-            { type: "start", partial: createAssistantMessage("") },
-            { type: "done", reason: "stop", message: mockMessage },
+    it('should stream through registered provider', async () => {
+        const mockMessage = createAssistantMessage('Hello from mock');
+        const provider = createMockProvider('mock-ai', [
+            { type: 'start', partial: createAssistantMessage('') },
+            { type: 'done', reason: 'stop', message: mockMessage },
         ]);
         registerProvider(provider);
         const model = {
-            id: "mock-model",
-            name: "Mock Model",
-            provider: "mock-ai",
-            api: "mock",
+            id: 'mock-model',
+            name: 'Mock Model',
+            provider: 'mock-ai',
+            api: 'mock',
         };
         const context = {
-            messages: [{ role: "user", content: "Hi", timestamp: Date.now() }],
+            messages: [{ role: 'user', content: 'Hi', timestamp: Date.now() }],
         };
         const eventStream = stream(model, context);
         const events = [];
@@ -222,57 +222,57 @@ describe("Provider Registry (pi-mono provider pattern)", () => {
             events.push(event);
         }
         expect(events.length).toBeGreaterThan(0);
-        const doneEvent = events.find((e) => e.type === "done");
+        const doneEvent = events.find((e) => e.type === 'done');
         expect(doneEvent).toBeDefined();
     });
-    it("should complete through registered provider", async () => {
-        const mockMessage = createAssistantMessage("Completed");
-        const provider = createMockProvider("complete-ai", [
-            { type: "start", partial: createAssistantMessage("") },
-            { type: "done", reason: "stop", message: mockMessage },
+    it('should complete through registered provider', async () => {
+        const mockMessage = createAssistantMessage('Completed');
+        const provider = createMockProvider('complete-ai', [
+            { type: 'start', partial: createAssistantMessage('') },
+            { type: 'done', reason: 'stop', message: mockMessage },
         ]);
         registerProvider(provider);
         const model = {
-            id: "complete-model",
-            name: "Complete Model",
-            provider: "complete-ai",
-            api: "complete",
+            id: 'complete-model',
+            name: 'Complete Model',
+            provider: 'complete-ai',
+            api: 'complete',
         };
         const context = {
-            messages: [{ role: "user", content: "Test", timestamp: Date.now() }],
+            messages: [{ role: 'user', content: 'Test', timestamp: Date.now() }],
         };
         const result = await complete(model, context);
-        expect(result.content[0]).toEqual({ type: "text", text: "Completed" });
+        expect(result.content[0]).toEqual({ type: 'text', text: 'Completed' });
     });
-    it("should throw for unregistered provider", () => {
+    it('should throw for unregistered provider', () => {
         const model = {
-            id: "unknown",
-            name: "Unknown",
-            provider: "nonexistent",
-            api: "unknown",
+            id: 'unknown',
+            name: 'Unknown',
+            provider: 'nonexistent',
+            api: 'unknown',
         };
         const context = { messages: [] };
-        expect(() => stream(model, context)).toThrow("No provider registered");
+        expect(() => stream(model, context)).toThrow('No provider registered');
     });
 });
-describe("Provider Error Handling", () => {
-    it("should emit error event on provider failure", async () => {
+describe('Provider Error Handling', () => {
+    it('should emit error event on provider failure', async () => {
         const errorProvider = {
-            name: "error-provider",
+            name: 'error-provider',
             stream() {
                 const stream = new AssistantMessageEventStream();
                 setTimeout(() => {
                     const errorMsg = {
-                        role: "assistant",
+                        role: 'assistant',
                         content: [],
-                        provider: "error-provider",
-                        model: "error-model",
+                        provider: 'error-provider',
+                        model: 'error-model',
                         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-                        stopReason: "error",
-                        errorMessage: "API Error",
+                        stopReason: 'error',
+                        errorMessage: 'API Error',
                         timestamp: Date.now(),
                     };
-                    stream.push({ type: "error", reason: "error", error: errorMsg });
+                    stream.push({ type: 'error', reason: 'error', error: errorMsg });
                     stream.end();
                 }, 10);
                 return stream;
@@ -280,22 +280,22 @@ describe("Provider Error Handling", () => {
         };
         registerProvider(errorProvider);
         const model = {
-            id: "error-model",
-            name: "Error Model",
-            provider: "error-provider",
-            api: "error",
+            id: 'error-model',
+            name: 'Error Model',
+            provider: 'error-provider',
+            api: 'error',
         };
         const context = { messages: [] };
         const result = await complete(model, context);
-        expect(result.stopReason).toBe("error");
-        expect(result.errorMessage).toBe("API Error");
+        expect(result.stopReason).toBe('error');
+        expect(result.errorMessage).toBe('API Error');
     });
 });
-describe("Streaming with AbortSignal", () => {
-    it("should respect abort signal", async () => {
+describe('Streaming with AbortSignal', () => {
+    it('should respect abort signal', async () => {
         const controller = new AbortController();
         const slowProvider = {
-            name: "slow-provider",
+            name: 'slow-provider',
             stream(model, context, options) {
                 const stream = new AssistantMessageEventStream();
                 // Simulate slow stream
@@ -303,23 +303,23 @@ describe("Streaming with AbortSignal", () => {
                     if (options?.signal?.aborted) {
                         clearInterval(interval);
                         const abortedMsg = {
-                            role: "assistant",
+                            role: 'assistant',
                             content: [],
-                            provider: "slow-provider",
-                            model: "slow-model",
+                            provider: 'slow-provider',
+                            model: 'slow-model',
                             usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-                            stopReason: "aborted",
+                            stopReason: 'aborted',
                             timestamp: Date.now(),
                         };
-                        stream.push({ type: "error", reason: "aborted", error: abortedMsg });
+                        stream.push({ type: 'error', reason: 'aborted', error: abortedMsg });
                         stream.end();
                         return;
                     }
                     stream.push({
-                        type: "text_delta",
+                        type: 'text_delta',
                         contentIndex: 0,
-                        delta: "chunk ",
-                        partial: createAssistantMessage(""),
+                        delta: 'chunk ',
+                        partial: createAssistantMessage(''),
                     });
                 }, 50);
                 // Auto-abort after 100ms
@@ -329,63 +329,63 @@ describe("Streaming with AbortSignal", () => {
         };
         registerProvider(slowProvider);
         const model = {
-            id: "slow-model",
-            name: "Slow Model",
-            provider: "slow-provider",
-            api: "slow",
+            id: 'slow-model',
+            name: 'Slow Model',
+            provider: 'slow-provider',
+            api: 'slow',
         };
         const context = { messages: [] };
         const eventStream = stream(model, context, { signal: controller.signal });
         const events = [];
         for await (const event of eventStream) {
             events.push(event);
-            if (event.type === "error" || event.type === "done")
+            if (event.type === 'error' || event.type === 'done')
                 break;
         }
         // Should have received at least one event before abort
         expect(events.length).toBeGreaterThan(0);
     });
 });
-describe("Message Content Types", () => {
-    it("should handle text content", async () => {
-        const message = createAssistantMessage("Plain text");
-        expect(message.content[0]).toEqual({ type: "text", text: "Plain text" });
+describe('Message Content Types', () => {
+    it('should handle text content', async () => {
+        const message = createAssistantMessage('Plain text');
+        expect(message.content[0]).toEqual({ type: 'text', text: 'Plain text' });
     });
-    it("should handle thinking content", async () => {
+    it('should handle thinking content', async () => {
         const message = {
-            role: "assistant",
+            role: 'assistant',
             content: [
-                { type: "thinking", thinking: "Let me think...", thinkingSignature: "sig1" },
-                { type: "text", text: "Answer" },
+                { type: 'thinking', thinking: 'Let me think...', thinkingSignature: 'sig1' },
+                { type: 'text', text: 'Answer' },
             ],
-            provider: "test",
-            model: "test",
+            provider: 'test',
+            model: 'test',
             usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-            stopReason: "stop",
+            stopReason: 'stop',
             timestamp: Date.now(),
         };
         expect(message.content).toHaveLength(2);
-        expect(message.content[0].type).toBe("thinking");
+        expect(message.content[0].type).toBe('thinking');
     });
-    it("should handle tool call content", async () => {
+    it('should handle tool call content', async () => {
         const message = {
-            role: "assistant",
+            role: 'assistant',
             content: [
                 {
-                    type: "toolCall",
-                    id: "call_1",
-                    name: "get_weather",
-                    arguments: { location: "NYC" },
+                    type: 'toolCall',
+                    id: 'call_1',
+                    name: 'get_weather',
+                    arguments: { location: 'NYC' },
                 },
             ],
-            provider: "test",
-            model: "test",
+            provider: 'test',
+            model: 'test',
             usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
-            stopReason: "toolUse",
+            stopReason: 'toolUse',
             timestamp: Date.now(),
         };
-        expect(message.content[0].type).toBe("toolCall");
-        expect(message.content[0].name).toBe("get_weather");
+        expect(message.content[0].type).toBe('toolCall');
+        expect(message.content[0].name).toBe('get_weather');
     });
 });
 //# sourceMappingURL=e2e.test.js.map