@chaoslabs/ai-sdk 0.0.2 → 0.0.4

package/dist/blocks.js

@@ -0,0 +1,246 @@
+// Chaos AI SDK - Block Utilities
+//
+// Helper functions for working with blocks extracted from responses.
+import { extractBlocks, isTableBlock, isChartBlock, isTransactionActionBlock, isMarkdownBlock, isInteractiveBlock, } from './types.js';
+// ============================================================================
+// Block Extraction Utilities
+// ============================================================================
+/**
+ * Extract all table blocks from a response.
+ */
+export function extractTableBlocks(response) {
+    return extractBlocks(response).filter(isTableBlock);
+}
+/**
+ * Extract all chart blocks from a response.
+ */
+export function extractChartBlocks(response) {
+    return extractBlocks(response).filter(isChartBlock);
+}
+/**
+ * Extract all transaction action blocks from a response.
+ */
+export function extractTransactionBlocks(response) {
+    return extractBlocks(response).filter(isTransactionActionBlock);
+}
+/**
+ * Extract all markdown blocks from a response.
+ */
+export function extractMarkdownBlocks(response) {
+    return extractBlocks(response).filter(isMarkdownBlock);
+}
+/**
+ * Extract all interactive blocks from a response.
+ */
+export function extractInteractiveBlocks(response) {
+    return extractBlocks(response).filter(isInteractiveBlock);
+}
+// ============================================================================
+// Block Search Utilities
+// ============================================================================
+/**
+ * Find the first table block with a matching title.
+ */
+export function findTableByTitle(response, title) {
+    return extractTableBlocks(response).find((block) => block.title.toLowerCase().includes(title.toLowerCase()));
+}
+/**
+ * Find the first chart block with a matching title.
+ */
+export function findChartByTitle(response, title) {
+    return extractChartBlocks(response).find((block) => block.title.toLowerCase().includes(title.toLowerCase()));
+}
+/**
+ * Find transaction blocks containing a specific primitive type.
+ */
+export function findTransactionsByPrimitive(response, primitiveType) {
+    return extractTransactionBlocks(response).filter((block) => block.primitives?.some((p) => p.primitive === primitiveType));
+}
+// ============================================================================
+// Primitive Extraction
+// ============================================================================
+/**
+ * Extract all primitives from all transaction blocks.
+ */
+export function extractPrimitives(response) {
+    const primitives = [];
+    for (const block of extractTransactionBlocks(response)) {
+        if (block.primitives) {
+            primitives.push(...block.primitives);
+        }
+    }
+    return primitives;
+}
+/**
+ * Extract primitives of a specific type.
+ */
+export function extractPrimitivesByType(response, primitiveType) {
+    return extractPrimitives(response).filter((p) => p.primitive === primitiveType);
+}
+/**
+ * Get unique primitive types from a response.
+ */
+export function getPrimitiveTypes(response) {
+    const types = new Set();
+    for (const primitive of extractPrimitives(response)) {
+        types.add(primitive.primitive);
+    }
+    return Array.from(types);
+}
+// ============================================================================
+// Table Utilities
+// ============================================================================
+/**
+ * Convert a table block to an array of objects.
+ * Each object has keys from the table headers.
+ */
+export function tableToObjects(table) {
+    const { tableHeaders, tableRows } = table;
+    return tableRows.map((row) => {
+        const obj = {};
+        for (let i = 0; i < tableHeaders.length; i++) {
+            obj[tableHeaders[i]] = row[i];
+        }
+        return obj;
+    });
+}
+/**
+ * Get a specific column from a table block.
+ */
+export function getTableColumn(table, columnName) {
+    const columnIndex = table.tableHeaders.indexOf(columnName);
+    if (columnIndex === -1)
+        return [];
+    return table.tableRows.map((row) => row[columnIndex]);
+}
+/**
+ * Find a row in a table by matching a column value.
+ */
+export function findTableRow(table, columnName, value) {
+    const columnIndex = table.tableHeaders.indexOf(columnName);
+    if (columnIndex === -1)
+        return undefined;
+    return table.tableRows.find((row) => row[columnIndex] === value);
+}
+/**
+ * Get table dimensions.
+ */
+export function getTableDimensions(table) {
+    return {
+        columns: table.tableHeaders.length,
+        rows: table.tableRows.length,
+    };
+}
+// ============================================================================
+// Chart Utilities
+// ============================================================================
+/**
+ * Get chart data as label-value pairs.
+ * Works with both segments and legacy data formats.
+ */
+export function getChartData(chart) {
+    if (chart.segments) {
+        return chart.segments.map((s) => ({ label: s.label, value: s.value }));
+    }
+    if (chart.data) {
+        return chart.data.map(([label, value]) => ({ label, value }));
+    }
+    return [];
+}
+/**
+ * Get the total value of all chart segments.
+ */
+export function getChartTotal(chart) {
+    return getChartData(chart).reduce((sum, item) => sum + item.value, 0);
+}
+/**
+ * Get chart segment percentages.
+ */
+export function getChartPercentages(chart) {
+    const data = getChartData(chart);
+    const total = data.reduce((sum, item) => sum + item.value, 0);
+    if (total === 0)
+        return data.map((d) => ({ label: d.label, percentage: 0 }));
+    return data.map((d) => ({
+        label: d.label,
+        percentage: (d.value / total) * 100,
+    }));
+}
+// ============================================================================
+// Risk Utilities
+// ============================================================================
+/**
+ * Get all warnings from transaction blocks.
+ */
+export function getAllWarnings(response) {
+    const warnings = [];
+    for (const block of extractTransactionBlocks(response)) {
+        if (block.risks?.warnings) {
+            warnings.push(...block.risks.warnings);
+        }
+    }
+    return warnings;
+}
+/**
+ * Get all blockers from transaction blocks.
+ */
+export function getAllBlockers(response) {
+    const blockers = [];
+    for (const block of extractTransactionBlocks(response)) {
+        if (block.risks?.blockers) {
+            blockers.push(...block.risks.blockers);
+        }
+    }
+    return blockers;
+}
+/**
+ * Get the highest risk level from all transaction blocks.
+ */
+export function getHighestRiskLevel(response) {
+    const riskLevels = ['low', 'medium', 'high', 'critical'];
+    let highestIndex = -1;
+    let highestLevel;
+    for (const block of extractTransactionBlocks(response)) {
+        if (block.risks?.level) {
+            const index = riskLevels.indexOf(block.risks.level.toLowerCase());
+            if (index > highestIndex) {
+                highestIndex = index;
+                highestLevel = block.risks.level;
+            }
+        }
+    }
+    return highestLevel;
+}
+// ============================================================================
+// Block Statistics
+// ============================================================================
+/**
+ * Count blocks by type in a response.
+ */
+export function countBlocksByType(response) {
+    const counts = {
+        table: 0,
+        chart: 0,
+        transaction_action: 0,
+        markdown: 0,
+        interactive: 0,
+    };
+    for (const block of extractBlocks(response)) {
+        if (block.type in counts) {
+            counts[block.type]++;
+        }
+    }
+    return counts;
+}
+/**
+ * Check if a response contains any blocks.
+ */
+export function hasBlocks(response) {
+    return extractBlocks(response).length > 0;
+}
+/**
+ * Check if a response contains a specific block type.
+ */
+export function hasBlockType(response, type) {
+    return extractBlocks(response).some((block) => block.type === type);
+}

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/conversation.d.ts

@@ -0,0 +1,136 @@
+import type { Chaos } from './client.js';
+import type { InputItem, Response, RequestMetadata } from './types.js';
+/**
+ * Options for creating a new conversation.
+ */
+export interface ConversationOptions {
+    /** Model to use (defaults to WALLET_MODEL) */
+    model?: string;
+    /** Maximum number of messages to keep in history */
+    maxHistoryLength?: number;
+    /** User identifier */
+    userId: string;
+    /** Wallet identifier */
+    walletId: string;
+    /** Optional initial session ID (auto-generated if not provided) */
+    sessionId?: string;
+}
+/**
+ * Statistics about the conversation.
+ */
+export interface ConversationStats {
+    /** Number of user turns */
+    userTurns: number;
+    /** Number of assistant turns */
+    assistantTurns: number;
+    /** Total messages in history */
+    totalMessages: number;
+    /** Session ID */
+    sessionId: string;
+    /** When the conversation started */
+    startedAt: Date;
+    /** When the last message was sent */
+    lastMessageAt: Date | null;
+}
+/**
+ * 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 declare class Conversation {
+    private client;
+    private model;
+    private maxHistoryLength;
+    private history;
+    private metadata;
+    private userTurns;
+    private assistantTurns;
+    private startedAt;
+    private lastMessageAt;
+    constructor(client: Chaos, options: ConversationOptions);
+    /**
+     * Get the current session ID.
+     */
+    get sessionId(): string;
+    /**
+     * Get the conversation history.
+     */
+    get messages(): readonly InputItem[];
+    /**
+     * Get conversation statistics.
+     */
+    get stats(): ConversationStats;
+    /**
+     * Send a message and get a response.
+     * Automatically manages conversation history.
+     */
+    send(message: string): Promise<Response>;
+    /**
+     * Add a user message to the history without sending.
+     * Useful for restoring conversation state.
+     */
+    addUserMessage(content: string): void;
+    /**
+     * Add an assistant message to the history.
+     * Useful for restoring conversation state.
+     */
+    addAssistantMessage(content: string): void;
+    /**
+     * Add a system message to the history.
+     */
+    addSystemMessage(content: string): void;
+    /**
+     * Reset the conversation to start fresh.
+     * Generates a new session ID and clears history.
+     */
+    reset(): void;
+    /**
+     * Clear the history but keep the same session ID.
+     */
+    clearHistory(): void;
+    /**
+     * Fork this conversation to create a branch.
+     * The new conversation has the same history but a new session ID.
+     */
+    fork(): Conversation;
+    /**
+     * Serialize the conversation to JSON for persistence.
+     */
+    toJSON(): {
+        sessionId: string;
+        history: InputItem[];
+        metadata: RequestMetadata;
+        stats: ConversationStats;
+    };
+    /**
+     * Restore conversation state from JSON.
+     */
+    static fromJSON(client: Chaos, data: {
+        sessionId: string;
+        history: InputItem[];
+        metadata: RequestMetadata;
+    }): Conversation;
+    /**
+     * Trim history to stay within maxHistoryLength.
+     */
+    private trimHistory;
+}