@chaoslabs/ai-sdk 0.0.2 → 0.0.4

package/dist/conversation.js

@@ -0,0 +1,230 @@
+// Chaos AI SDK - Conversation Management
+//
+// A class for managing multi-turn conversations with history tracking.
+import { extractText } from './types.js';
+import { WALLET_MODEL } from './request.js';
+/**
+ * Manages a multi-turn conversation with history tracking.
+ *
+ * @example
+ * ```typescript
+ * import { Chaos, Conversation } from '@chaoslabs/ai-sdk';
+ *
+ * const chaos = new Chaos({ apiKey: 'ck-...' });
+ * const conversation = new Conversation(chaos, {
+ *   userId: 'user-123',
+ *   walletId: '0x...',
+ * });
+ *
+ * // Send messages - history is tracked automatically
+ * const response1 = await conversation.send("What's my portfolio value?");
+ * const response2 = await conversation.send("Which asset has the highest allocation?");
+ *
+ * // Get conversation stats
+ * console.log(conversation.stats);
+ *
+ * // Reset for a new conversation
+ * conversation.reset();
+ * ```
+ */
+export class Conversation {
+    client;
+    model;
+    maxHistoryLength;
+    history = [];
+    metadata;
+    userTurns = 0;
+    assistantTurns = 0;
+    startedAt;
+    lastMessageAt = null;
+    constructor(client, options) {
+        this.client = client;
+        this.model = options.model || WALLET_MODEL;
+        this.maxHistoryLength = options.maxHistoryLength || 50;
+        this.startedAt = new Date();
+        this.metadata = {
+            user_id: options.userId,
+            wallet_id: options.walletId,
+            session_id: options.sessionId || `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        };
+    }
+    /**
+     * Get the current session ID.
+     */
+    get sessionId() {
+        return this.metadata.session_id;
+    }
+    /**
+     * Get the conversation history.
+     */
+    get messages() {
+        return [...this.history];
+    }
+    /**
+     * Get conversation statistics.
+     */
+    get stats() {
+        return {
+            userTurns: this.userTurns,
+            assistantTurns: this.assistantTurns,
+            totalMessages: this.history.length,
+            sessionId: this.metadata.session_id,
+            startedAt: this.startedAt,
+            lastMessageAt: this.lastMessageAt,
+        };
+    }
+    /**
+     * Send a message and get a response.
+     * Automatically manages conversation history.
+     */
+    async send(message) {
+        // Add user message to history
+        this.addUserMessage(message);
+        // Send request with full history
+        const response = await this.client.chat.responses.create({
+            model: this.model,
+            input: [...this.history],
+            metadata: this.metadata,
+        });
+        // Add assistant response to history if successful
+        if (response.status === 'completed') {
+            const text = extractText(response);
+            if (text) {
+                this.addAssistantMessage(text);
+            }
+        }
+        this.lastMessageAt = new Date();
+        return response;
+    }
+    /**
+     * Add a user message to the history without sending.
+     * Useful for restoring conversation state.
+     */
+    addUserMessage(content) {
+        this.history.push({
+            type: 'message',
+            role: 'user',
+            content,
+        });
+        this.userTurns++;
+        this.trimHistory();
+    }
+    /**
+     * Add an assistant message to the history.
+     * Useful for restoring conversation state.
+     */
+    addAssistantMessage(content) {
+        // Store assistant responses as user messages with prefix for context
+        // This matches the pattern used in the multi-turn example
+        this.history.push({
+            type: 'message',
+            role: 'user',
+            content: `[Assistant]: ${content}`,
+        });
+        this.assistantTurns++;
+        this.trimHistory();
+    }
+    /**
+     * Add a system message to the history.
+     */
+    addSystemMessage(content) {
+        this.history.push({
+            type: 'message',
+            role: 'system',
+            content,
+        });
+        this.trimHistory();
+    }
+    /**
+     * Reset the conversation to start fresh.
+     * Generates a new session ID and clears history.
+     */
+    reset() {
+        this.history = [];
+        this.userTurns = 0;
+        this.assistantTurns = 0;
+        this.startedAt = new Date();
+        this.lastMessageAt = null;
+        this.metadata.session_id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    /**
+     * Clear the history but keep the same session ID.
+     */
+    clearHistory() {
+        this.history = [];
+        this.userTurns = 0;
+        this.assistantTurns = 0;
+    }
+    /**
+     * Fork this conversation to create a branch.
+     * The new conversation has the same history but a new session ID.
+     */
+    fork() {
+        const forked = new Conversation(this.client, {
+            model: this.model,
+            maxHistoryLength: this.maxHistoryLength,
+            userId: this.metadata.user_id,
+            walletId: this.metadata.wallet_id,
+        });
+        // Copy history
+        for (const msg of this.history) {
+            if (msg.role === 'user') {
+                if (msg.content.startsWith('[Assistant]: ')) {
+                    forked.history.push(msg);
+                    forked.assistantTurns++;
+                }
+                else {
+                    forked.history.push(msg);
+                    forked.userTurns++;
+                }
+            }
+            else {
+                forked.history.push(msg);
+            }
+        }
+        return forked;
+    }
+    /**
+     * Serialize the conversation to JSON for persistence.
+     */
+    toJSON() {
+        return {
+            sessionId: this.metadata.session_id,
+            history: [...this.history],
+            metadata: { ...this.metadata },
+            stats: this.stats,
+        };
+    }
+    /**
+     * Restore conversation state from JSON.
+     */
+    static fromJSON(client, data) {
+        const conversation = new Conversation(client, {
+            userId: data.metadata.user_id,
+            walletId: data.metadata.wallet_id,
+            sessionId: data.sessionId,
+        });
+        // Restore history
+        for (const msg of data.history) {
+            conversation.history.push(msg);
+            if (msg.role === 'user') {
+                if (msg.content.startsWith('[Assistant]: ')) {
+                    conversation.assistantTurns++;
+                }
+                else {
+                    conversation.userTurns++;
+                }
+            }
+        }
+        return conversation;
+    }
+    /**
+     * Trim history to stay within maxHistoryLength.
+     */
+    trimHistory() {
+        if (this.history.length > this.maxHistoryLength) {
+            const excess = this.history.length - this.maxHistoryLength;
+            this.history = this.history.slice(excess);
+        }
+    }
+}

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;
+}

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,3 +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 { 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,8 +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 stream message utilities
+export { isAgentStatusMessage, isAgentMessage, isReportMessage, isFollowUpSuggestions, isUserInputMessage, parseAgentStatus, isTerminalStatus, extractAgentMessageText, extractSuggestions, extractReportBlock, parseStreamLine, parseStreamLines, } from './stream.js';