@chaoslabs/ai-sdk 0.0.3 → 0.0.5

package/dist/__tests__/stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/stream.test.js

@@ -0,0 +1,345 @@
+import { describe, it, expect } from "bun:test";
+import { isAgentStatusMessage, isAgentMessage, isReportMessage, isFollowUpSuggestions, isUserInputMessage, parseAgentStatus, isTerminalStatus, extractAgentMessageText, extractSuggestions, extractReportBlock, parseStreamLine, parseStreamLines, } from "../stream";
+describe("isAgentStatusMessage", () => {
+    it("returns true for agent_status_change message", () => {
+        const msg = {
+            id: "1",
+            type: "agent_status_change",
+            timestamp: Date.now(),
+            content: { status: "processing" },
+            context: {
+                sessionId: "session-1",
+                artifactId: "artifact-1",
+            },
+        };
+        expect(isAgentStatusMessage(msg)).toBe(true);
+    });
+    it("returns false for other message types", () => {
+        const msg = {
+            id: "2",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: {
+                sessionId: "session-1",
+                artifactId: "artifact-1",
+            },
+        };
+        expect(isAgentStatusMessage(msg)).toBe(false);
+    });
+});
+describe("isAgentMessage", () => {
+    it("returns true for agent_message type", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isAgentMessage(msg)).toBe(true);
+    });
+    it("returns false for other message types", () => {
+        const msg = {
+            id: "1",
+            type: "report",
+            timestamp: Date.now(),
+            content: { id: "r1", type: "table", data: {} },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isAgentMessage(msg)).toBe(false);
+    });
+});
+describe("isReportMessage", () => {
+    it("returns true for report type", () => {
+        const msg = {
+            id: "1",
+            type: "report",
+            timestamp: Date.now(),
+            content: { id: "r1", type: "table", data: {} },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isReportMessage(msg)).toBe(true);
+    });
+    it("returns false for other message types", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isReportMessage(msg)).toBe(false);
+    });
+});
+describe("isFollowUpSuggestions", () => {
+    it("returns true for follow_up_suggestions type", () => {
+        const msg = {
+            id: "1",
+            type: "follow_up_suggestions",
+            timestamp: Date.now(),
+            content: { suggestions: ["Question 1?", "Question 2?"] },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isFollowUpSuggestions(msg)).toBe(true);
+    });
+    it("returns false for other message types", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isFollowUpSuggestions(msg)).toBe(false);
+    });
+});
+describe("isUserInputMessage", () => {
+    it("returns true for user_input type", () => {
+        const msg = {
+            id: "1",
+            type: "user_input",
+            timestamp: Date.now(),
+            content: { query: "What is my balance?" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isUserInputMessage(msg)).toBe(true);
+    });
+    it("returns false for other message types", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(isUserInputMessage(msg)).toBe(false);
+    });
+});
+describe("parseAgentStatus", () => {
+    it("extracts status from agent_status_change message", () => {
+        const msg = {
+            id: "1",
+            type: "agent_status_change",
+            timestamp: Date.now(),
+            content: { status: "processing" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(parseAgentStatus(msg)).toBe("processing");
+    });
+    it("extracts done status", () => {
+        const msg = {
+            id: "1",
+            type: "agent_status_change",
+            timestamp: Date.now(),
+            content: { status: "done" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(parseAgentStatus(msg)).toBe("done");
+    });
+    it("returns null for non-status messages", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(parseAgentStatus(msg)).toBeNull();
+    });
+    it("returns null for invalid content", () => {
+        const msg = {
+            id: "1",
+            type: "agent_status_change",
+            timestamp: Date.now(),
+            content: { notStatus: "wrong" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(parseAgentStatus(msg)).toBeNull();
+    });
+});
+describe("isTerminalStatus", () => {
+    it("returns true for done status", () => {
+        expect(isTerminalStatus("done")).toBe(true);
+    });
+    it("returns true for error status", () => {
+        expect(isTerminalStatus("error")).toBe(true);
+    });
+    it("returns true for cancelled status", () => {
+        expect(isTerminalStatus("cancelled")).toBe(true);
+    });
+    it("returns false for processing status", () => {
+        expect(isTerminalStatus("processing")).toBe(false);
+    });
+});
+describe("extractAgentMessageText", () => {
+    it("extracts message text from agent_message", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello world" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractAgentMessageText(msg)).toBe("Hello world");
+    });
+    it("returns null for non-agent_message types", () => {
+        const msg = {
+            id: "1",
+            type: "report",
+            timestamp: Date.now(),
+            content: { id: "r1", type: "table", data: {} },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractAgentMessageText(msg)).toBeNull();
+    });
+    it("returns null for invalid content structure", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1" }, // missing data.message
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractAgentMessageText(msg)).toBeNull();
+    });
+});
+describe("extractSuggestions", () => {
+    it("extracts suggestions array from follow_up_suggestions", () => {
+        const msg = {
+            id: "1",
+            type: "follow_up_suggestions",
+            timestamp: Date.now(),
+            content: { suggestions: ["Question 1?", "Question 2?"] },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractSuggestions(msg)).toEqual(["Question 1?", "Question 2?"]);
+    });
+    it("returns empty array for non-follow_up_suggestions types", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractSuggestions(msg)).toEqual([]);
+    });
+    it("returns empty array for invalid content structure", () => {
+        const msg = {
+            id: "1",
+            type: "follow_up_suggestions",
+            timestamp: Date.now(),
+            content: { notSuggestions: "wrong" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractSuggestions(msg)).toEqual([]);
+    });
+});
+describe("extractReportBlock", () => {
+    it("extracts data from report message", () => {
+        const reportData = { columns: ["name"], rows: [["Alice"]] };
+        const msg = {
+            id: "1",
+            type: "report",
+            timestamp: Date.now(),
+            content: { id: "r1", type: "table", data: reportData },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractReportBlock(msg)).toEqual(reportData);
+    });
+    it("returns null for non-report types", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: Date.now(),
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractReportBlock(msg)).toBeNull();
+    });
+    it("returns null for invalid content structure", () => {
+        const msg = {
+            id: "1",
+            type: "report",
+            timestamp: Date.now(),
+            content: { id: "r1", type: "table" }, // missing data
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        expect(extractReportBlock(msg)).toBeNull();
+    });
+});
+describe("parseStreamLine", () => {
+    it("parses valid NDJSON line to StreamMessage", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: 1234567890,
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        const line = JSON.stringify(msg);
+        const result = parseStreamLine(line);
+        expect(result).toEqual(msg);
+    });
+    it("returns null for empty line", () => {
+        expect(parseStreamLine("")).toBeNull();
+    });
+    it("returns null for whitespace-only line", () => {
+        expect(parseStreamLine("   ")).toBeNull();
+    });
+    it("returns null for invalid JSON", () => {
+        expect(parseStreamLine("{not valid json}")).toBeNull();
+    });
+    it("returns null for missing required fields", () => {
+        expect(parseStreamLine('{"id": "1"}')).toBeNull();
+    });
+});
+describe("parseStreamLines", () => {
+    it("parses multiple NDJSON lines", () => {
+        const msg1 = {
+            id: "1",
+            type: "agent_status_change",
+            timestamp: 1234567890,
+            content: { status: "processing" },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        const msg2 = {
+            id: "2",
+            type: "agent_message",
+            timestamp: 1234567891,
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        const text = JSON.stringify(msg1) + "\n" + JSON.stringify(msg2);
+        const result = parseStreamLines(text);
+        expect(result).toEqual([msg1, msg2]);
+    });
+    it("returns empty array for empty string", () => {
+        expect(parseStreamLines("")).toEqual([]);
+    });
+    it("skips invalid lines and returns valid ones", () => {
+        const validMsg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: 1234567890,
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        const text = "invalid json\n" + JSON.stringify(validMsg) + "\n{broken}";
+        const result = parseStreamLines(text);
+        expect(result).toEqual([validMsg]);
+    });
+    it("handles lines with various whitespace", () => {
+        const msg = {
+            id: "1",
+            type: "agent_message",
+            timestamp: 1234567890,
+            content: { messageId: "m1", data: { message: "Hello" } },
+            context: { sessionId: "s1", artifactId: "a1" },
+        };
+        const text = "\n\n" + JSON.stringify(msg) + "\n\n";
+        const result = parseStreamLines(text);
+        expect(result).toEqual([msg]);
+    });
+});

package/dist/__tests__/trivial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/trivial.test.js

@@ -0,0 +1,6 @@
+import { describe, it, expect } from 'bun:test';
+describe('test infrastructure', () => {
+    it('works', () => {
+        expect(1 + 1).toBe(2);
+    });
+});

package/dist/client.d.ts

@@ -1,23 +1,33 @@
 import type { ChaosConfig, CreateResponseParams, Response } from './types.js';
 import { WALLET_MODEL, ASK_MODEL } from './request.js';
+import { StreamingHttpClient } from './http-streaming.js';
 export { WALLET_MODEL, ASK_MODEL };
+/**
+ * Extended config with useNativeHttp option
+ */
+interface ExtendedChaosConfig extends ChaosConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeout: number;
+    useNativeHttp: boolean;
+}
 /**
  * The v1 responses API namespace.
  */
 declare class V1Responses {
     private config;
     private sessionId;
-    private abortController;
-    constructor(config: Required<ChaosConfig>);
+    private streamingClient;
+    constructor(config: ExtendedChaosConfig);
     private generateId;
     /**
      * Create a response using v1 API.
      */
     create(params: CreateResponseParams): Promise<Response>;
     /**
-     * Create a non-streaming response.
+     * Create a response using native HTTP streaming.
      */
-    private createNonStreaming;
+    private createWithNativeHttp;
     /**
      * Cancel the current request.
      */
@@ -32,7 +42,7 @@ declare class V1Responses {
  */
 declare class V1Chat {
     readonly responses: V1Responses;
-    constructor(config: Required<ChaosConfig>);
+    constructor(config: ExtendedChaosConfig);
 }
 /**
  * Chaos AI SDK Client - V1 API.
@@ -64,6 +74,8 @@ declare class V1Chat {
 export declare class Chaos {
     readonly chat: V1Chat;
     private config;
+    /** Whether to use native http module for streaming */
+    readonly useNativeHttp: boolean;
     constructor(config: ChaosConfig);
     /**
      * Get the API key.
@@ -73,5 +85,9 @@ export declare class Chaos {
      * Get the base URL.
      */
     get baseUrl(): string;
+    /**
+     * Get a StreamingHttpClient instance for direct streaming access.
+     */
+    getStreamingClient(): StreamingHttpClient;
 }
 export default Chaos;

package/dist/client.js

@@ -3,23 +3,37 @@
 // This client talks to the new v1 API endpoint with Bearer auth.
 import { ChaosError, ChaosTimeoutError } from './types.js';
 import { toV1WalletRequest, toV1AskRequest, buildV1Headers, buildV1Endpoint, WALLET_MODEL, ASK_MODEL, } from './request.js';
-import { parseV1Stream, toV1Response } from './response.js';
+import { toV1Response } from './response.js';
+import { parseStreamLine } from './stream.js';
+import { StreamingHttpClient } from './http-streaming.js';
+/**
+ * Build final state from a list of stream events.
+ */
+function buildFinalStateFromEvents(events) {
+    const blocks = [];
+    for (const event of events) {
+        if (event.type === 'report' && event.content) {
+            const content = event.content;
+            if (content.data) {
+                blocks.push(content.data);
+            }
+        }
+    }
+    return { blocks };
+}
 // Export model constants
 export { WALLET_MODEL, ASK_MODEL };
 // ============================================================================
 // Constants
 // ============================================================================
 const DEFAULT_TIMEOUT = 120000; // 2 minutes
-// ============================================================================
-// V1 Responses Class
-// ============================================================================
 /**
  * The v1 responses API namespace.
  */
 class V1Responses {
     config;
     sessionId;
-    abortController = null;
+    streamingClient = null;
     constructor(config) {
         this.config = config;
         this.sessionId = this.generateId();
@@ -31,48 +45,63 @@ class V1Responses {
      * Create a response using v1 API.
      */
     async create(params) {
-        return this.createNonStreaming(params);
+        // Always use native HTTP for true streaming behavior
+        return this.createWithNativeHttp(params);
     }
     /**
-     * Create a non-streaming response.
+     * Create a response using native HTTP streaming.
      */
-    async createNonStreaming(params) {
+    async createWithNativeHttp(params) {
         const responseId = this.generateId();
         const sessionId = params.metadata.session_id || this.sessionId;
-        // Create abort controller for timeout
-        this.abortController = new AbortController();
-        const timeoutSignal = AbortSignal.timeout(this.config.timeout);
-        const signal = AbortSignal.any([this.abortController.signal, timeoutSignal]);
+        // Create streaming client
+        this.streamingClient = new StreamingHttpClient({
+            baseUrl: this.config.baseUrl,
+            timeout: this.config.timeout,
+        });
         // Build request
-        const endpoint = buildV1Endpoint(this.config.baseUrl);
         const headers = buildV1Headers(this.config.apiKey);
         // Check if wallet or ask mode
         const isWallet = params.model === WALLET_MODEL || params.model.includes('WALLET');
         const requestBody = isWallet
             ? toV1WalletRequest(params, sessionId)
             : toV1AskRequest(params, sessionId);
+        // Build endpoint path
+        const endpoint = buildV1Endpoint(this.config.baseUrl);
+        const url = new URL(endpoint);
+        const path = url.pathname + url.search;
         try {
-            // Make request
-            const response = await fetch(endpoint, {
+            // Collect events for final response
+            const events = [];
+            // Stream lines using native http
+            for await (const line of this.streamingClient.streamLines(path, {
                 method: 'POST',
                 headers,
                 body: JSON.stringify(requestBody),
-                signal,
-            });
-            if (!response.ok) {
-                throw new ChaosError(`HTTP error: ${response.status} ${response.statusText}`, response.status);
+            })) {
+                try {
+                    const event = JSON.parse(line);
+                    events.push(event);
+                    // Call stream event callback if provided
+                    if (params.onStreamEvent) {
+                        const msg = parseStreamLine(line);
+                        if (msg) {
+                            params.onStreamEvent(msg);
+                        }
+                    }
+                }
+                catch {
+                    // Skip invalid JSON lines
+                }
             }
-            if (!response.body) {
-                throw new ChaosError('Response body is null');
-            }
-            // Parse NDJSON stream
-            const finalState = await parseV1Stream(response.body);
+            // Build final state from events
+            const finalState = buildFinalStateFromEvents(events);
             // Convert to Response
             return toV1Response(responseId, params.model, finalState);
         }
         catch (error) {
-            if (error instanceof Error && error.name === 'TimeoutError') {
-                throw new ChaosTimeoutError(this.config.timeout);
+            if (error instanceof ChaosTimeoutError) {
+                throw error;
             }
             if (error instanceof ChaosError) {
                 throw error;
@@ -80,15 +109,17 @@ class V1Responses {
             throw new ChaosError(error instanceof Error ? error.message : String(error));
         }
         finally {
-            this.abortController = null;
+            this.streamingClient = null;
         }
     }
     /**
      * Cancel the current request.
      */
     cancel() {
-        this.abortController?.abort();
-        this.abortController = null;
+        // Cancel native HTTP streaming client
+        if (this.streamingClient) {
+            this.streamingClient.abort();
+        }
     }
     /**
      * Reset the session for a new conversation.
@@ -143,12 +174,18 @@ class V1Chat {
 export class Chaos {
     chat;
     config;
+    /** Whether to use native http module for streaming */
+    useNativeHttp;
     constructor(config) {
+        // Default useNativeHttp to true for proper streaming
+        const useNativeHttp = config.useNativeHttp !== false;
         this.config = {
             apiKey: config.apiKey,
             baseUrl: config.baseUrl || 'https://ai-staging.chaoslabs.co',
             timeout: config.timeout || DEFAULT_TIMEOUT,
+            useNativeHttp,
         };
+        this.useNativeHttp = useNativeHttp;
         this.chat = new V1Chat(this.config);
     }
     /**
@@ -163,5 +200,14 @@ export class Chaos {
     get baseUrl() {
         return this.config.baseUrl;
     }
+    /**
+     * Get a StreamingHttpClient instance for direct streaming access.
+     */
+    getStreamingClient() {
+        return new StreamingHttpClient({
+            baseUrl: this.config.baseUrl,
+            timeout: this.config.timeout,
+        });
+    }
 }
 export default Chaos;

package/dist/http-streaming.d.ts

@@ -0,0 +1,55 @@
+export interface HttpStreamOptions {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    timeout: number;
+}
+export interface StreamingHttpClientOptions {
+    baseUrl: string;
+    timeout: number;
+}
+export interface StreamRequestOptions {
+    method: string;
+    headers?: Record<string, string>;
+    body: string;
+}
+/**
+ * Makes an HTTP request using Node's native http/https modules and returns
+ * an async iterator that yields chunks as they arrive (true streaming).
+ *
+ * @param options - Request options
+ * @returns AsyncIterable that yields string chunks
+ */
+export declare function httpStreamRequest(options: HttpStreamOptions): AsyncIterable<string>;
+/**
+ * High-level HTTP streaming client that provides methods for streaming
+ * requests with proper chunk and line parsing.
+ */
+export declare class StreamingHttpClient {
+    private baseUrl;
+    private timeout;
+    private aborted;
+    private currentIterator;
+    constructor(options: StreamingHttpClientOptions);
+    /**
+     * Stream raw chunks from a request.
+     *
+     * @param path - URL path (will be appended to baseUrl)
+     * @param options - Request options
+     * @returns AsyncIterable of raw string chunks
+     */
+    stream(path: string, options: StreamRequestOptions): AsyncIterable<string>;
+    /**
+     * Stream parsed NDJSON lines from a request.
+     *
+     * @param path - URL path (will be appended to baseUrl)
+     * @param options - Request options
+     * @returns AsyncIterable of complete JSON lines (without newline)
+     */
+    streamLines(path: string, options: StreamRequestOptions): AsyncIterable<string>;
+    /**
+     * Abort the current in-progress request.
+     */
+    abort(): void;
+}