@chaoslabs/ai-sdk 0.0.3 → 0.0.4

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

@@ -0,0 +1,1401 @@
+/**
+ * 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);
+    });
+});