@chaoslabs/ai-sdk 0.0.5 → 0.0.7

package/dist/__tests__/http-streaming.test.js

@@ -1,1401 +0,0 @@
-/**
- * HTTP Streaming Tests (TDD - RED Phase)
- *
- * These tests verify the http-based streaming implementation that will replace fetch.
- * Tests are written BEFORE the implementation (TDD RED phase).
- *
- * The implementation will use Node's native http/https modules for streaming
- * instead of fetch to ensure proper incremental streaming behavior.
- *
- * KEY TESTS THAT MUST FAIL INITIALLY:
- * - httpStreamRequest function (doesn't exist yet)
- * - StreamingHttpClient class (doesn't exist yet)
- * - useNativeHttp option (doesn't exist yet)
- */
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "bun:test";
-import * as http from "node:http";
-import { Chaos, WALLET_MODEL } from "../client";
-import { ChaosError, ChaosTimeoutError } from "../types";
-// ============================================================================
-// Dynamic Import for TDD - Module Doesn't Exist Yet
-// ============================================================================
-// These will be undefined until we implement the http streaming module
-let httpStreamRequest;
-let StreamingHttpClient;
-// Try to import the module - it won't exist until implementation
-try {
-    // @ts-expect-error - Module doesn't exist yet (TDD RED phase)
-    const httpStreaming = await import("../http-streaming");
-    httpStreamRequest = httpStreaming.httpStreamRequest;
-    StreamingHttpClient = httpStreaming.StreamingHttpClient;
-}
-catch {
-    // Expected to fail until module is implemented
-    httpStreamRequest = undefined;
-    StreamingHttpClient = undefined;
-}
-// ============================================================================
-// Test Utilities
-// ============================================================================
-/**
- * Creates a mock HTTP server that streams NDJSON responses.
- */
-function createMockServer(handler) {
-    return http.createServer(handler);
-}
-/**
- * Creates a valid stream message for testing.
- */
-function createStreamMessage(id, type, content) {
-    return {
-        id,
-        type,
-        timestamp: Date.now(),
-        content,
-        context: {
-            sessionId: "test-session",
-            artifactId: "test-artifact",
-        },
-    };
-}
-/**
- * Creates a valid NDJSON line from a stream message.
- */
-function toNDJSON(msg) {
-    return JSON.stringify(msg) + "\n";
-}
-// ============================================================================
-// Test Suite: Incremental Streaming
-// ============================================================================
-describe("HTTP Streaming - Incremental Event Delivery", () => {
-    let server;
-    let serverPort;
-    beforeAll(async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Send messages with delays to simulate real streaming
-            const messages = [
-                createStreamMessage("1", "agent_status_change", { status: "processing" }),
-                createStreamMessage("2", "agent_message", {
-                    messageId: "m1",
-                    data: { message: "First message" },
-                }),
-                createStreamMessage("3", "agent_message", {
-                    messageId: "m2",
-                    data: { message: "Second message" },
-                }),
-                createStreamMessage("4", "report", {
-                    id: "r1",
-                    type: "table",
-                    data: { blockType: "table", title: "Test", tableHeaders: [], tableRows: [] },
-                }),
-                createStreamMessage("5", "agent_status_change", { status: "done" }),
-            ];
-            let index = 0;
-            const sendNext = () => {
-                if (index < messages.length) {
-                    res.write(toNDJSON(messages[index]));
-                    index++;
-                    setTimeout(sendNext, 50); // 50ms delay between messages
-                }
-                else {
-                    res.end();
-                }
-            };
-            sendNext();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-    });
-    afterAll(() => {
-        server.close();
-    });
-    it("fires onStreamEvent callback for each message as data arrives", async () => {
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        const receivedEvents = [];
-        const receivedTimestamps = [];
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-                receivedTimestamps.push(Date.now());
-            },
-        });
-        // Should receive all 5 messages
-        expect(receivedEvents.length).toBe(5);
-        // Events should arrive incrementally (with time gaps between them)
-        // If they arrived all at once, timestamps would be nearly identical
-        for (let i = 1; i < receivedTimestamps.length; i++) {
-            const timeDiff = receivedTimestamps[i] - receivedTimestamps[i - 1];
-            // Should have at least 20ms gap (server sends with 50ms delay)
-            expect(timeDiff).toBeGreaterThanOrEqual(20);
-        }
-        // Verify message types in order
-        expect(receivedEvents[0].type).toBe("agent_status_change");
-        expect(receivedEvents[1].type).toBe("agent_message");
-        expect(receivedEvents[2].type).toBe("agent_message");
-        expect(receivedEvents[3].type).toBe("report");
-        expect(receivedEvents[4].type).toBe("agent_status_change");
-    });
-    it("does not buffer all events before calling callback", async () => {
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        let firstEventTime = null;
-        let lastEventTime = null;
-        let eventCount = 0;
-        const startTime = Date.now();
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: () => {
-                const now = Date.now();
-                if (firstEventTime === null) {
-                    firstEventTime = now;
-                }
-                lastEventTime = now;
-                eventCount++;
-            },
-        });
-        // Total time should be close to 5 messages * 50ms = 250ms
-        const totalTime = lastEventTime - firstEventTime;
-        // If events were buffered, totalTime would be near 0
-        // With streaming, it should be at least 150ms (accounting for some variance)
-        expect(totalTime).toBeGreaterThanOrEqual(150);
-        expect(eventCount).toBe(5);
-    });
-});
-// ============================================================================
-// Test Suite: Chunked Data Handling
-// ============================================================================
-describe("HTTP Streaming - Chunked Data Handling", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("handles partial JSON lines split across multiple data events", async () => {
-        // Create a message that will be split across chunks
-        const fullMessage = createStreamMessage("1", "agent_message", {
-            messageId: "m1",
-            data: { message: "This is a complete message that was split" },
-        });
-        const fullLine = JSON.stringify(fullMessage);
-        // Split the line at various points
-        const chunk1 = fullLine.substring(0, 20);
-        const chunk2 = fullLine.substring(20, 50);
-        const chunk3 = fullLine.substring(50) + "\n";
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Send chunks with delays
-            res.write(chunk1);
-            setTimeout(() => res.write(chunk2), 20);
-            setTimeout(() => res.write(chunk3), 40);
-            setTimeout(() => res.end(), 60);
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        const receivedEvents = [];
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-            },
-        });
-        // Should correctly reassemble the split message
-        expect(receivedEvents.length).toBe(1);
-        expect(receivedEvents[0].id).toBe("1");
-        expect(receivedEvents[0].type).toBe("agent_message");
-        const content = receivedEvents[0].content;
-        expect(content.data.message).toBe("This is a complete message that was split");
-    });
-    it("handles multiple complete messages in a single chunk", async () => {
-        const msg1 = createStreamMessage("1", "agent_status_change", { status: "processing" });
-        const msg2 = createStreamMessage("2", "agent_message", {
-            messageId: "m1",
-            data: { message: "Hello" },
-        });
-        const msg3 = createStreamMessage("3", "agent_status_change", { status: "done" });
-        // All messages in one chunk
-        const allMessages = toNDJSON(msg1) + toNDJSON(msg2) + toNDJSON(msg3);
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            res.write(allMessages);
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        const receivedEvents = [];
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-            },
-        });
-        expect(receivedEvents.length).toBe(3);
-        expect(receivedEvents[0].id).toBe("1");
-        expect(receivedEvents[1].id).toBe("2");
-        expect(receivedEvents[2].id).toBe("3");
-    });
-    it("handles messages split mid-UTF8 character", async () => {
-        // Message with unicode characters that might be split mid-character
-        const fullMessage = createStreamMessage("1", "agent_message", {
-            messageId: "m1",
-            data: { message: "Hello \u{1F4B0} and \u{1F680} tokens!" },
-        });
-        const fullLine = JSON.stringify(fullMessage) + "\n";
-        // Convert to buffer and split at byte level (might split UTF-8 sequences)
-        const buffer = Buffer.from(fullLine, "utf8");
-        const midPoint = Math.floor(buffer.length / 2);
-        const chunk1 = buffer.subarray(0, midPoint);
-        const chunk2 = buffer.subarray(midPoint);
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            res.write(chunk1);
-            setTimeout(() => {
-                res.write(chunk2);
-                res.end();
-            }, 30);
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        const receivedEvents = [];
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-            },
-        });
-        expect(receivedEvents.length).toBe(1);
-        const content = receivedEvents[0].content;
-        expect(content.data.message).toContain("\u{1F4B0}");
-        expect(content.data.message).toContain("\u{1F680}");
-    });
-});
-// ============================================================================
-// Test Suite: Timeout Handling
-// ============================================================================
-describe("HTTP Streaming - Timeout Handling", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("throws ChaosTimeoutError when request exceeds timeout", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Send initial data then hang
-            const msg = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            res.write(toNDJSON(msg));
-            // Never send more data - let it timeout
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 200, // Very short timeout
-        });
-        await expect(chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        })).rejects.toThrow(ChaosTimeoutError);
-    });
-    it("includes timeout duration in error message", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Hang indefinitely
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 300,
-        });
-        try {
-            await chaos.chat.responses.create({
-                model: WALLET_MODEL,
-                input: [{ type: "message", role: "user", content: "Test query" }],
-                metadata: {
-                    user_id: "test-user",
-                    session_id: "test-session",
-                    wallet_id: "0x123",
-                },
-            });
-            expect.fail("Should have thrown");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(ChaosTimeoutError);
-            expect(error.message).toContain("300");
-        }
-    });
-    it("does not timeout when data arrives within timeout window", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Send messages quickly
-            const msg1 = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            const msg2 = createStreamMessage("2", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg1));
-            setTimeout(() => {
-                res.write(toNDJSON(msg2));
-                res.end();
-            }, 50);
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 5000,
-        });
-        const receivedEvents = [];
-        // Should complete without throwing
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-            },
-        });
-        expect(receivedEvents.length).toBe(2);
-    });
-});
-// ============================================================================
-// Test Suite: HTTP Error Handling
-// ============================================================================
-describe("HTTP Streaming - HTTP Error Handling", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("throws ChaosError with status code for 4xx responses", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Unauthorized" }));
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "invalid-key",
-            baseUrl: `http://localhost:${serverPort}`,
-        });
-        try {
-            await chaos.chat.responses.create({
-                model: WALLET_MODEL,
-                input: [{ type: "message", role: "user", content: "Test query" }],
-                metadata: {
-                    user_id: "test-user",
-                    session_id: "test-session",
-                    wallet_id: "0x123",
-                },
-            });
-            expect.fail("Should have thrown");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(ChaosError);
-            expect(error.status).toBe(401);
-        }
-    });
-    it("throws ChaosError with status code for 5xx responses", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(503, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Service Unavailable" }));
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-        });
-        try {
-            await chaos.chat.responses.create({
-                model: WALLET_MODEL,
-                input: [{ type: "message", role: "user", content: "Test query" }],
-                metadata: {
-                    user_id: "test-user",
-                    session_id: "test-session",
-                    wallet_id: "0x123",
-                },
-            });
-            expect.fail("Should have thrown");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(ChaosError);
-            expect(error.status).toBe(503);
-        }
-    });
-    it("includes HTTP status text in error message", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(429, "Too Many Requests", { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Rate limited" }));
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-        });
-        try {
-            await chaos.chat.responses.create({
-                model: WALLET_MODEL,
-                input: [{ type: "message", role: "user", content: "Test query" }],
-                metadata: {
-                    user_id: "test-user",
-                    session_id: "test-session",
-                    wallet_id: "0x123",
-                },
-            });
-            expect.fail("Should have thrown");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(ChaosError);
-            expect(error.message).toContain("429");
-        }
-    });
-});
-// ============================================================================
-// Test Suite: Connection Error Handling
-// ============================================================================
-describe("HTTP Streaming - Connection Error Handling", () => {
-    it("throws ChaosError when server is unreachable", async () => {
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: "http://localhost:59999", // Port that is not listening
-            timeout: 5000,
-        });
-        await expect(chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        })).rejects.toThrow(ChaosError);
-    });
-    it("handles connection reset mid-stream", async () => {
-        const server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            res.write(toNDJSON(msg));
-            // Destroy the socket to simulate connection reset
-            setTimeout(() => {
-                req.socket?.destroy();
-            }, 50);
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => resolve());
-        });
-        const addr = server.address();
-        const serverPort = typeof addr === "object" && addr ? addr.port : 0;
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 5000,
-        });
-        try {
-            await chaos.chat.responses.create({
-                model: WALLET_MODEL,
-                input: [{ type: "message", role: "user", content: "Test query" }],
-                metadata: {
-                    user_id: "test-user",
-                    session_id: "test-session",
-                    wallet_id: "0x123",
-                },
-            });
-            expect.fail("Should have thrown");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(ChaosError);
-        }
-        finally {
-            server.close();
-        }
-    });
-    it("handles DNS resolution failure", async () => {
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: "http://this-domain-does-not-exist-12345.invalid",
-            timeout: 5000,
-        });
-        await expect(chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        })).rejects.toThrow(ChaosError);
-    });
-});
-// ============================================================================
-// Test Suite: Protocol Support
-// ============================================================================
-describe("HTTP Streaming - Protocol Support", () => {
-    let httpServer;
-    let httpPort;
-    afterEach(() => {
-        if (httpServer) {
-            httpServer.close();
-        }
-    });
-    it("works with http:// URLs", async () => {
-        httpServer = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const msg1 = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            const msg2 = createStreamMessage("2", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg1));
-            res.write(toNDJSON(msg2));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            httpServer.listen(0, () => {
-                const addr = httpServer.address();
-                httpPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${httpPort}`,
-        });
-        const receivedEvents = [];
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-            },
-        });
-        expect(receivedEvents.length).toBe(2);
-    });
-    it("uses correct protocol module based on URL scheme", async () => {
-        // This test verifies that http:// URLs use the http module
-        // and https:// URLs would use the https module
-        // Since we can't easily test https without certificates in unit tests,
-        // we verify http works and document that https should work identically
-        httpServer = createMockServer((req, res) => {
-            // Verify the request came through correctly
-            expect(req.method).toBe("POST");
-            expect(req.headers["content-type"]).toBe("application/json");
-            expect(req.headers["authorization"]).toContain("Bearer");
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            httpServer.listen(0, () => {
-                const addr = httpServer.address();
-                httpPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${httpPort}`,
-        });
-        // Should complete without error
-        const response = await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        });
-        expect(response).toBeDefined();
-        expect(response.status).toBe("completed");
-    });
-    it("handles URL with port in baseUrl", async () => {
-        httpServer = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            httpServer.listen(0, () => {
-                const addr = httpServer.address();
-                httpPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${httpPort}`,
-        });
-        const response = await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        });
-        expect(response).toBeDefined();
-    });
-    it("handles URL with path in baseUrl", async () => {
-        httpServer = createMockServer((req, res) => {
-            // The path should include the base path plus the API endpoint
-            expect(req.url).toContain("/api");
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            httpServer.listen(0, () => {
-                const addr = httpServer.address();
-                httpPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${httpPort}/api`,
-        });
-        const response = await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        });
-        expect(response).toBeDefined();
-    });
-});
-// ============================================================================
-// Test Suite: Request Cancellation
-// ============================================================================
-describe("HTTP Streaming - Request Cancellation", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("can cancel an in-progress streaming request", async () => {
-        let requestReceived = false;
-        server = createMockServer((req, res) => {
-            requestReceived = true;
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            res.write(toNDJSON(msg));
-            // Keep sending data slowly
-            const interval = setInterval(() => {
-                const msg = createStreamMessage("2", "agent_message", {
-                    messageId: "m1",
-                    data: { message: "Still processing..." },
-                });
-                try {
-                    res.write(toNDJSON(msg));
-                }
-                catch {
-                    clearInterval(interval);
-                }
-            }, 100);
-            req.on("close", () => {
-                clearInterval(interval);
-            });
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        const receivedEvents = [];
-        // Start the request but cancel it after receiving some events
-        const requestPromise = chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test query" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-            onStreamEvent: (event) => {
-                receivedEvents.push(event);
-                if (receivedEvents.length >= 2) {
-                    // Cancel after receiving 2 events
-                    chaos.chat.responses.cancel();
-                }
-            },
-        });
-        // The request should either throw or complete early
-        try {
-            await requestPromise;
-        }
-        catch (error) {
-            // Cancellation may throw an error, which is acceptable
-            expect(error).toBeInstanceOf(Error);
-        }
-        expect(requestReceived).toBe(true);
-        // Should have received some events before cancellation
-        expect(receivedEvents.length).toBeGreaterThanOrEqual(1);
-    });
-});
-// ============================================================================
-// Test Suite: Low-Level HTTP Streaming Module (TDD - Will Fail Until Implemented)
-// ============================================================================
-describe("HTTP Streaming Module - httpStreamRequest Function", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("exports httpStreamRequest function", () => {
-        // This test will fail because the module doesn't exist yet
-        expect(typeof httpStreamRequest).toBe("function");
-    });
-    it("httpStreamRequest returns an async iterator of chunks", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chunks = [];
-        const iterator = httpStreamRequest({
-            url: `http://localhost:${serverPort}/v1/chat/stream`,
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: "Bearer test-key",
-            },
-            body: JSON.stringify({ query: "test" }),
-            timeout: 5000,
-        });
-        for await (const chunk of iterator) {
-            chunks.push(chunk);
-        }
-        expect(chunks.length).toBeGreaterThan(0);
-        expect(chunks.join("")).toContain("agent_status_change");
-    });
-    it("httpStreamRequest yields chunks as they arrive (not buffered)", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const messages = [
-                createStreamMessage("1", "agent_status_change", { status: "processing" }),
-                createStreamMessage("2", "agent_message", { data: { message: "Hello" } }),
-                createStreamMessage("3", "agent_status_change", { status: "done" }),
-            ];
-            let index = 0;
-            const sendNext = () => {
-                if (index < messages.length) {
-                    res.write(toNDJSON(messages[index]));
-                    index++;
-                    setTimeout(sendNext, 100);
-                }
-                else {
-                    res.end();
-                }
-            };
-            sendNext();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chunkTimestamps = [];
-        const iterator = httpStreamRequest({
-            url: `http://localhost:${serverPort}/v1/chat/stream`,
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: "{}",
-            timeout: 5000,
-        });
-        for await (const chunk of iterator) {
-            chunkTimestamps.push(Date.now());
-        }
-        // Chunks should arrive with time gaps (streaming, not buffered)
-        expect(chunkTimestamps.length).toBeGreaterThanOrEqual(2);
-        for (let i = 1; i < chunkTimestamps.length; i++) {
-            const gap = chunkTimestamps[i] - chunkTimestamps[i - 1];
-            // Should have at least some gap (>50ms) if truly streaming
-            expect(gap).toBeGreaterThanOrEqual(50);
-        }
-    });
-    it("httpStreamRequest throws on connection error", async () => {
-        await expect((async () => {
-            const iterator = httpStreamRequest({
-                url: "http://localhost:59999/nonexistent",
-                method: "POST",
-                headers: {},
-                body: "{}",
-                timeout: 1000,
-            });
-            for await (const _ of iterator) {
-                // Should not reach here
-            }
-        })()).rejects.toThrow();
-    });
-    it("httpStreamRequest throws on HTTP error status", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Internal Server Error" }));
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        await expect((async () => {
-            const iterator = httpStreamRequest({
-                url: `http://localhost:${serverPort}/v1/chat/stream`,
-                method: "POST",
-                headers: {},
-                body: "{}",
-                timeout: 5000,
-            });
-            for await (const _ of iterator) {
-                // Should throw before iterating
-            }
-        })()).rejects.toThrow();
-    });
-    it("httpStreamRequest respects timeout", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            // Send one chunk then hang
-            res.write('{"partial": true}\n');
-            // Never end the response
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const startTime = Date.now();
-        await expect((async () => {
-            const iterator = httpStreamRequest({
-                url: `http://localhost:${serverPort}/v1/chat/stream`,
-                method: "POST",
-                headers: {},
-                body: "{}",
-                timeout: 300,
-            });
-            for await (const _ of iterator) {
-                // Should timeout
-            }
-        })()).rejects.toThrow();
-        const elapsed = Date.now() - startTime;
-        // Should timeout around 300ms, with some tolerance
-        expect(elapsed).toBeLessThan(1000);
-        expect(elapsed).toBeGreaterThanOrEqual(250);
-    });
-});
-describe("HTTP Streaming Module - StreamingHttpClient Class", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("exports StreamingHttpClient class", () => {
-        expect(typeof StreamingHttpClient).toBe("function");
-    });
-    it("StreamingHttpClient.stream returns async iterator", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const client = new StreamingHttpClient({
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 5000,
-        });
-        const chunks = [];
-        for await (const chunk of client.stream("/v1/chat/stream", {
-            method: "POST",
-            headers: { Authorization: "Bearer test" },
-            body: "{}",
-        })) {
-            chunks.push(chunk);
-        }
-        expect(chunks.length).toBeGreaterThan(0);
-    });
-    it("StreamingHttpClient.abort cancels in-progress request", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "application/x-ndjson",
-                "Transfer-Encoding": "chunked",
-            });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            res.write(toNDJSON(msg));
-            // Keep streaming indefinitely
-            const interval = setInterval(() => {
-                try {
-                    res.write('{"keep": "alive"}\n');
-                }
-                catch {
-                    clearInterval(interval);
-                }
-            }, 50);
-            req.on("close", () => {
-                clearInterval(interval);
-            });
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const client = new StreamingHttpClient({
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 10000,
-        });
-        let chunkCount = 0;
-        const abortPromise = new Promise((resolve) => {
-            setTimeout(() => {
-                client.abort();
-                resolve();
-            }, 200);
-        });
-        try {
-            for await (const chunk of client.stream("/v1/chat/stream", {
-                method: "POST",
-                body: "{}",
-            })) {
-                chunkCount++;
-                if (chunkCount > 10)
-                    break; // Safety limit
-            }
-        }
-        catch (error) {
-            // Abort should cause an error
-            expect(error).toBeInstanceOf(Error);
-        }
-        await abortPromise;
-        expect(chunkCount).toBeLessThan(10);
-    });
-    it("StreamingHttpClient handles https:// URLs", async () => {
-        // Note: This test documents the expected behavior for HTTPS
-        // In practice, testing HTTPS requires certificates
-        const client = new StreamingHttpClient({
-            baseUrl: "https://example.com",
-            timeout: 5000,
-        });
-        // The client should use https module for https:// URLs
-        // We can verify this by checking internal state or behavior
-        expect(client).toBeDefined();
-        // The actual HTTPS test would require a real HTTPS server
-        // For now, we document that it should work
-    });
-    it("StreamingHttpClient parses NDJSON lines correctly", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            const msg1 = createStreamMessage("1", "agent_status_change", { status: "processing" });
-            const msg2 = createStreamMessage("2", "agent_message", {
-                data: { message: "Hello world" },
-            });
-            const msg3 = createStreamMessage("3", "agent_status_change", { status: "done" });
-            // Send with slight delays
-            res.write(toNDJSON(msg1));
-            setTimeout(() => res.write(toNDJSON(msg2)), 30);
-            setTimeout(() => {
-                res.write(toNDJSON(msg3));
-                res.end();
-            }, 60);
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const client = new StreamingHttpClient({
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 5000,
-        });
-        const lines = [];
-        for await (const line of client.streamLines("/v1/chat/stream", {
-            method: "POST",
-            body: "{}",
-        })) {
-            lines.push(line);
-        }
-        expect(lines.length).toBe(3);
-        expect(JSON.parse(lines[0]).id).toBe("1");
-        expect(JSON.parse(lines[1]).id).toBe("2");
-        expect(JSON.parse(lines[2]).id).toBe("3");
-    });
-});
-describe("HTTP Streaming Module - Chaos Client Integration", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("Chaos client accepts useNativeHttp option in config", () => {
-        // This test will fail until we add the useNativeHttp option
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: "http://localhost:3000",
-            // @ts-expect-error - Option doesn't exist yet (TDD RED phase)
-            useNativeHttp: true,
-        });
-        // The config should accept this option
-        expect(chaos).toBeDefined();
-        // @ts-expect-error - Property doesn't exist yet
-        expect(chaos.useNativeHttp).toBe(true);
-    });
-    it("Chaos client uses http module when useNativeHttp is true", async () => {
-        let requestMethod;
-        let connectionHeader;
-        server = createMockServer((req, res) => {
-            requestMethod = req.method;
-            connectionHeader = req.headers["connection"];
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            const msg = createStreamMessage("1", "agent_status_change", { status: "done" });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: `http://localhost:${serverPort}`,
-            // @ts-expect-error - Option doesn't exist yet (TDD RED phase)
-            useNativeHttp: true,
-        });
-        await chaos.chat.responses.create({
-            model: WALLET_MODEL,
-            input: [{ type: "message", role: "user", content: "Test" }],
-            metadata: {
-                user_id: "test-user",
-                session_id: "test-session",
-                wallet_id: "0x123",
-            },
-        });
-        expect(requestMethod).toBe("POST");
-        // When using native http, we should see the connection header handled differently
-        // This is implementation-specific and may need adjustment
-    });
-    it("getStreamingClient returns StreamingHttpClient instance", () => {
-        const chaos = new Chaos({
-            apiKey: "test-api-key",
-            baseUrl: "http://localhost:3000",
-        });
-        // @ts-expect-error - Method doesn't exist yet
-        const streamingClient = chaos.getStreamingClient();
-        expect(streamingClient).toBeInstanceOf(StreamingHttpClient);
-    });
-});
-describe("HTTP Streaming Module - Edge Cases", () => {
-    let server;
-    let serverPort;
-    afterEach(() => {
-        if (server) {
-            server.close();
-        }
-    });
-    it("handles empty response body gracefully", async () => {
-        server = createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            res.end(); // Empty body
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const chunks = [];
-        const iterator = httpStreamRequest({
-            url: `http://localhost:${serverPort}/v1/chat/stream`,
-            method: "POST",
-            headers: {},
-            body: "{}",
-            timeout: 5000,
-        });
-        for await (const chunk of iterator) {
-            chunks.push(chunk);
-        }
-        // Should complete without error, with zero or minimal chunks
-        expect(chunks.length).toBeLessThanOrEqual(1);
-    });
-    it("handles very large chunks", async () => {
-        const largeData = "x".repeat(100000); // 100KB of data
-        const largeMessage = createStreamMessage("1", "agent_message", {
-            data: { message: largeData },
-        });
-        server = createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            res.write(toNDJSON(largeMessage));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const allData = [];
-        const iterator = httpStreamRequest({
-            url: `http://localhost:${serverPort}/v1/chat/stream`,
-            method: "POST",
-            headers: {},
-            body: "{}",
-            timeout: 10000,
-        });
-        for await (const chunk of iterator) {
-            allData.push(chunk);
-        }
-        const combined = allData.join("");
-        expect(combined).toContain(largeData);
-    });
-    it("handles rapid successive requests", async () => {
-        let requestCount = 0;
-        server = createMockServer((req, res) => {
-            requestCount++;
-            res.writeHead(200, { "Content-Type": "application/x-ndjson" });
-            const msg = createStreamMessage(String(requestCount), "agent_status_change", {
-                status: "done",
-            });
-            res.write(toNDJSON(msg));
-            res.end();
-        });
-        await new Promise((resolve) => {
-            server.listen(0, () => {
-                const addr = server.address();
-                serverPort = typeof addr === "object" && addr ? addr.port : 0;
-                resolve();
-            });
-        });
-        const client = new StreamingHttpClient({
-            baseUrl: `http://localhost:${serverPort}`,
-            timeout: 5000,
-        });
-        // Make 5 rapid requests
-        const results = await Promise.all(Array.from({ length: 5 }, async (_, i) => {
-            const chunks = [];
-            for await (const chunk of client.stream("/v1/chat/stream", {
-                method: "POST",
-                body: JSON.stringify({ request: i }),
-            })) {
-                chunks.push(chunk);
-            }
-            return chunks.join("");
-        }));
-        expect(results.length).toBe(5);
-        expect(requestCount).toBe(5);
-    });
-});