@chaoslabs/ai-sdk 0.0.3 → 0.0.5

package/dist/http-streaming.js

@@ -0,0 +1,359 @@
+// HTTP Streaming Module
+//
+// This module provides low-level HTTP streaming using Node's native http/https modules.
+// It yields data incrementally as it arrives, unlike fetch which buffers the response.
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { ChaosError, ChaosTimeoutError } from './types.js';
+// ============================================================================
+// httpStreamRequest - Low-level streaming function
+// ============================================================================
+/**
+ * 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 function httpStreamRequest(options) {
+    const { url, method, headers, body, timeout } = options;
+    return {
+        [Symbol.asyncIterator]() {
+            const parsedUrl = new URL(url);
+            const isHttps = parsedUrl.protocol === 'https:';
+            const httpModule = isHttps ? https : http;
+            let request = null;
+            let response = null;
+            let destroyed = false;
+            let pendingChunks = [];
+            let resolveNext = null;
+            let rejectNext = null;
+            let ended = false;
+            let error = null;
+            let requestStarted = false;
+            let requestPromise = null;
+            // Store timeout reference so we can restart it
+            let timeoutId = null;
+            // Store the startRequest reject function so timeout can use it
+            let startRequestReject = null;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                if (request && !destroyed) {
+                    destroyed = true;
+                    request.destroy();
+                }
+                if (response) {
+                    response.removeAllListeners();
+                }
+            };
+            const resetTimeout = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                if (!ended && !destroyed && !error) {
+                    timeoutId = setTimeout(() => {
+                        const err = new ChaosTimeoutError(timeout);
+                        // Set error BEFORE cleanup so that handleEnd doesn't resolve
+                        error = err;
+                        // Reject the appropriate promise
+                        if (rejectNext) {
+                            // We're waiting for data during iteration
+                            const reject = rejectNext;
+                            rejectNext = null;
+                            resolveNext = null;
+                            reject(err);
+                        }
+                        else if (startRequestReject) {
+                            // We're still waiting for the response headers
+                            const reject = startRequestReject;
+                            startRequestReject = null;
+                            reject(err);
+                        }
+                        cleanup();
+                    }, timeout);
+                }
+            };
+            const handleError = (err) => {
+                if (error)
+                    return; // Already have an error
+                error = err;
+                cleanup();
+                if (rejectNext) {
+                    rejectNext(err);
+                    rejectNext = null;
+                    resolveNext = null;
+                }
+            };
+            const handleData = (chunk) => {
+                // Reset timeout on each data chunk
+                resetTimeout();
+                const str = chunk.toString('utf8');
+                if (resolveNext) {
+                    resolveNext({ value: str, done: false });
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+                else {
+                    pendingChunks.push(str);
+                }
+            };
+            const handleEnd = () => {
+                ended = true;
+                // Don't cleanup yet - let the caller handle it
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                if (resolveNext && !error) {
+                    resolveNext({ value: undefined, done: true });
+                    resolveNext = null;
+                    rejectNext = null;
+                }
+            };
+            // Start the request
+            const requestOptions = {
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port || (isHttps ? 443 : 80),
+                path: parsedUrl.pathname + parsedUrl.search,
+                method,
+                headers: {
+                    ...headers,
+                    'Content-Length': Buffer.byteLength(body, 'utf8').toString(),
+                },
+            };
+            const startRequest = () => {
+                return new Promise((resolve, reject) => {
+                    // Store reject so timeout can use it
+                    startRequestReject = reject;
+                    // Start initial timeout
+                    resetTimeout();
+                    request = httpModule.request(requestOptions, (res) => {
+                        response = res;
+                        // Reset timeout when we get response
+                        resetTimeout();
+                        // Check for HTTP errors
+                        if (res.statusCode && res.statusCode >= 400) {
+                            let errorBody = '';
+                            res.on('data', (chunk) => {
+                                errorBody += chunk.toString();
+                            });
+                            res.on('end', () => {
+                                const err = new ChaosError(`HTTP error: ${res.statusCode} ${res.statusMessage || ''}`, res.statusCode);
+                                handleError(err);
+                                reject(err);
+                            });
+                            res.on('error', () => {
+                                // Ignore errors during error body collection
+                            });
+                            return;
+                        }
+                        // Set up data handlers
+                        res.on('data', handleData);
+                        res.on('end', handleEnd);
+                        res.on('error', (err) => {
+                            handleError(new ChaosError(`Stream error: ${err.message}`));
+                        });
+                        res.on('close', () => {
+                            // If closed without ending properly, it's an error
+                            if (!ended && !error) {
+                                handleError(new ChaosError('Connection closed unexpectedly'));
+                            }
+                        });
+                        // Clear startRequestReject since we've resolved
+                        startRequestReject = null;
+                        resolve();
+                    });
+                    request.on('error', (err) => {
+                        const chaosErr = new ChaosError(`Connection error: ${err.message}`);
+                        handleError(chaosErr);
+                        reject(chaosErr);
+                    });
+                    request.on('timeout', () => {
+                        const err = new ChaosTimeoutError(timeout);
+                        handleError(err);
+                        reject(err);
+                    });
+                    // Send the request body
+                    request.write(body);
+                    request.end();
+                });
+            };
+            return {
+                async next() {
+                    // Start request on first next() call
+                    if (!requestStarted) {
+                        requestStarted = true;
+                        requestPromise = startRequest();
+                        try {
+                            await requestPromise;
+                        }
+                        catch (err) {
+                            throw err;
+                        }
+                    }
+                    // Check for error
+                    if (error) {
+                        throw error;
+                    }
+                    // Check for pending chunks
+                    if (pendingChunks.length > 0) {
+                        return { value: pendingChunks.shift(), done: false };
+                    }
+                    // Check if ended
+                    if (ended) {
+                        return { value: undefined, done: true };
+                    }
+                    // Wait for next chunk (timeout will fire if nothing comes)
+                    return new Promise((resolve, reject) => {
+                        resolveNext = resolve;
+                        rejectNext = reject;
+                    });
+                },
+                async return() {
+                    cleanup();
+                    return { value: undefined, done: true };
+                },
+                async throw(err) {
+                    cleanup();
+                    throw err;
+                },
+            };
+        },
+    };
+}
+// ============================================================================
+// StreamingHttpClient - High-level streaming client
+// ============================================================================
+/**
+ * High-level HTTP streaming client that provides methods for streaming
+ * requests with proper chunk and line parsing.
+ */
+export class StreamingHttpClient {
+    baseUrl;
+    timeout;
+    aborted = false;
+    currentIterator = null;
+    constructor(options) {
+        this.baseUrl = options.baseUrl;
+        this.timeout = options.timeout;
+    }
+    /**
+     * 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, options) {
+        const fullUrl = this.baseUrl + path;
+        this.aborted = false;
+        const self = this;
+        const innerIterable = httpStreamRequest({
+            url: fullUrl,
+            method: options.method,
+            headers: options.headers || {},
+            body: options.body,
+            timeout: this.timeout,
+        });
+        return {
+            [Symbol.asyncIterator]() {
+                const iterator = innerIterable[Symbol.asyncIterator]();
+                self.currentIterator = iterator;
+                return {
+                    async next() {
+                        if (self.aborted) {
+                            // Call return to cleanup the underlying iterator
+                            await iterator.return?.();
+                            throw new ChaosError('Request aborted');
+                        }
+                        try {
+                            const result = await iterator.next();
+                            if (self.aborted) {
+                                await iterator.return?.();
+                                throw new ChaosError('Request aborted');
+                            }
+                            return result;
+                        }
+                        catch (err) {
+                            if (self.aborted) {
+                                throw new ChaosError('Request aborted');
+                            }
+                            throw err;
+                        }
+                    },
+                    async return() {
+                        self.currentIterator = null;
+                        return iterator.return?.() || { value: undefined, done: true };
+                    },
+                    async throw(err) {
+                        self.currentIterator = null;
+                        return iterator.throw?.(err) || Promise.reject(err);
+                    },
+                };
+            },
+        };
+    }
+    /**
+     * 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, options) {
+        const rawStream = this.stream(path, options);
+        return {
+            [Symbol.asyncIterator]() {
+                const rawIterator = rawStream[Symbol.asyncIterator]();
+                let buffer = '';
+                return {
+                    async next() {
+                        while (true) {
+                            // Check for complete lines in buffer
+                            const newlineIndex = buffer.indexOf('\n');
+                            if (newlineIndex !== -1) {
+                                const line = buffer.substring(0, newlineIndex);
+                                buffer = buffer.substring(newlineIndex + 1);
+                                if (line.trim()) {
+                                    return { value: line, done: false };
+                                }
+                                continue;
+                            }
+                            // Get more data
+                            const result = await rawIterator.next();
+                            if (result.done) {
+                                // Handle remaining buffer
+                                if (buffer.trim()) {
+                                    const remaining = buffer.trim();
+                                    buffer = '';
+                                    return { value: remaining, done: false };
+                                }
+                                return { value: undefined, done: true };
+                            }
+                            buffer += result.value;
+                        }
+                    },
+                    async return() {
+                        return rawIterator.return?.() || { value: undefined, done: true };
+                    },
+                    async throw(err) {
+                        return rawIterator.throw?.(err) || Promise.reject(err);
+                    },
+                };
+            },
+        };
+    }
+    /**
+     * Abort the current in-progress request.
+     */
+    abort() {
+        this.aborted = true;
+        if (this.currentIterator) {
+            this.currentIterator.return?.();
+            this.currentIterator = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { Chaos as default, Chaos, WALLET_MODEL, ASK_MODEL } from './client.js';
+export { httpStreamRequest, StreamingHttpClient } from './http-streaming.js';
+export type { HttpStreamOptions, StreamingHttpClientOptions, StreamRequestOptions } from './http-streaming.js';
 export type { V1WalletRequest, V1AskRequest } from './request.js';
 export type { V1StreamEvent, V1FinalState } from './response.js';
 export type { ChaosConfig, CreateResponseParams, RequestMetadata, InputItem, Response, OutputItem, ContentPart, Block, OutputText, ChaosBlock, MarkdownBlock, TableBlock, TableColumnType, TableSortDirection, TableColumnConfig, ChartBlock, ChartSeries, ChartSegment, ChartAxis, ChartDataPoint, TransactionActionBlock, Primitive, PrimitiveIcon, PrimitiveLineItem, PrimitiveDisplay, RawTransaction, TransactionGroup, Risks, RiskInfoItem, InteractiveBlock, InteractiveOption, ResponseError, } from './types.js';
@@ -6,8 +8,5 @@ export { ChaosError, ChaosTimeoutError } from './types.js';
 export { extractText, extractBlocks, hasRisks, hasBlockers, isTableBlock, isChartBlock, isTransactionActionBlock, isInteractiveBlock, isMarkdownBlock, isOutputText, isChaosBlock, } from './types.js';
 export { BlockSchema, parseRawBlock, detectBlockType } from './schemas.js';
 export type { BlockParsed } from './schemas.js';
-export { Conversation } from './conversation.js';
-export type { ConversationOptions, ConversationStats } from './conversation.js';
-export { PRIMITIVE_SWAP, PRIMITIVE_SUPPLY, PRIMITIVE_WITHDRAW, PRIMITIVE_BORROW, PRIMITIVE_REPAY, PRIMITIVE_STAKE, PRIMITIVE_UNSTAKE, PRIMITIVE_CLAIM, PRIMITIVE_BRIDGE, PRIMITIVE_ADD_LIQUIDITY, PRIMITIVE_REMOVE_LIQUIDITY, PRIMITIVE_OPEN_POSITION, PRIMITIVE_CLOSE_POSITION, PRIMITIVE_DEPOSIT, PRIMITIVE_MINT, PRIMITIVE_BURN, PRIMITIVE_RESTAKE, PRIMITIVE_APPROVE, PRIMITIVE_TRANSFER, PRIMITIVE_WRAP, PRIMITIVE_UNWRAP, ALL_PRIMITIVES, LENDING_PRIMITIVES, TRADING_PRIMITIVES, STAKING_PRIMITIVES, LIQUIDITY_PRIMITIVES, TRANSFER_PRIMITIVES, isValidPrimitive, isLendingPrimitive, isTradingPrimitive, isStakingPrimitive, isLiquidityPrimitive, isTransferPrimitive, } from './primitives.js';
-export type { PrimitiveType } from './primitives.js';
-export { extractTableBlocks, extractChartBlocks, extractTransactionBlocks, extractMarkdownBlocks, extractInteractiveBlocks, findTableByTitle, findChartByTitle, findTransactionsByPrimitive, extractPrimitives, extractPrimitivesByType, getPrimitiveTypes, tableToObjects, getTableColumn, findTableRow, getTableDimensions, getChartData, getChartTotal, getChartPercentages, getAllWarnings, getAllBlockers, getHighestRiskLevel, countBlocksByType, hasBlocks, hasBlockType, } from './blocks.js';
+export { isAgentStatusMessage, isAgentMessage, isReportMessage, isFollowUpSuggestions, isUserInputMessage, parseAgentStatus, isTerminalStatus, extractAgentMessageText, extractSuggestions, extractReportBlock, parseStreamLine, parseStreamLines, } from './stream.js';
+export type { MessageType, AgentStatus, StreamMessage, StreamMessageContext, } from './stream.js';

package/dist/index.js

@@ -1,34 +1,11 @@
 // Chaos AI SDK V1 - Public API
 export { Chaos as default, Chaos, WALLET_MODEL, ASK_MODEL } from './client.js';
+export { httpStreamRequest, StreamingHttpClient } from './http-streaming.js';
 // Export error classes
 export { ChaosError, ChaosTimeoutError } from './types.js';
 // Export helper functions
 export { extractText, extractBlocks, hasRisks, hasBlockers, isTableBlock, isChartBlock, isTransactionActionBlock, isInteractiveBlock, isMarkdownBlock, isOutputText, isChaosBlock, } from './types.js';
 // Export schemas for validation
 export { BlockSchema, parseRawBlock, detectBlockType } from './schemas.js';
-// Export Conversation class
-export { Conversation } from './conversation.js';
-// Export primitive constants and helpers
-export { 
-// Primitive type constants
-PRIMITIVE_SWAP, PRIMITIVE_SUPPLY, PRIMITIVE_WITHDRAW, PRIMITIVE_BORROW, PRIMITIVE_REPAY, PRIMITIVE_STAKE, PRIMITIVE_UNSTAKE, PRIMITIVE_CLAIM, PRIMITIVE_BRIDGE, PRIMITIVE_ADD_LIQUIDITY, PRIMITIVE_REMOVE_LIQUIDITY, PRIMITIVE_OPEN_POSITION, PRIMITIVE_CLOSE_POSITION, PRIMITIVE_DEPOSIT, PRIMITIVE_MINT, PRIMITIVE_BURN, PRIMITIVE_RESTAKE, PRIMITIVE_APPROVE, PRIMITIVE_TRANSFER, PRIMITIVE_WRAP, PRIMITIVE_UNWRAP, 
-// Primitive categories
-ALL_PRIMITIVES, LENDING_PRIMITIVES, TRADING_PRIMITIVES, STAKING_PRIMITIVES, LIQUIDITY_PRIMITIVES, TRANSFER_PRIMITIVES, 
-// Primitive helpers
-isValidPrimitive, isLendingPrimitive, isTradingPrimitive, isStakingPrimitive, isLiquidityPrimitive, isTransferPrimitive, } from './primitives.js';
-// Export block utilities
-export { 
-// Block extraction
-extractTableBlocks, extractChartBlocks, extractTransactionBlocks, extractMarkdownBlocks, extractInteractiveBlocks, 
-// Block search
-findTableByTitle, findChartByTitle, findTransactionsByPrimitive, 
-// Primitive extraction
-extractPrimitives, extractPrimitivesByType, getPrimitiveTypes, 
-// Table utilities
-tableToObjects, getTableColumn, findTableRow, getTableDimensions, 
-// Chart utilities
-getChartData, getChartTotal, getChartPercentages, 
-// Risk utilities
-getAllWarnings, getAllBlockers, getHighestRiskLevel, 
-// Block statistics
-countBlocksByType, hasBlocks, hasBlockType, } from './blocks.js';
+// Export stream message utilities
+export { isAgentStatusMessage, isAgentMessage, isReportMessage, isFollowUpSuggestions, isUserInputMessage, parseAgentStatus, isTerminalStatus, extractAgentMessageText, extractSuggestions, extractReportBlock, parseStreamLine, parseStreamLines, } from './stream.js';