npm install @chaoslabs/ai-sdk

import { Chaos, type ChaosConfig } from '@chaoslabs/ai-sdk';
 
interface ChaosConfig {
  apiKey: string;          // Required: Your API key
  baseUrl?: string;        // Optional: API URL (default: https://ai-staging.chaoslabs.co)
  timeout?: number;        // Optional: Request timeout in ms (default: 120000)
}
 
const chaos = new Chaos({
  apiKey: process.env.CHAOS_API_KEY!,
  baseUrl: 'https://ai-staging.chaoslabs.co',
  timeout: 120000,
});

import {
  WALLET_MODEL,
  ASK_MODEL,
  type CreateResponseParams,
  type InputItem,
  type RequestMetadata
} from '@chaoslabs/ai-sdk';
 
interface CreateResponseParams {
  model: string;              // WALLET_MODEL or ASK_MODEL
  input: InputItem[];         // Conversation messages
  metadata: RequestMetadata;  // User/session/wallet info
  stream?: boolean;           // Enable streaming
}
 
interface InputItem {
  type: 'message';
  role: 'user' | 'system';
  content: string;
}
 
interface RequestMetadata {
  user_id: string;      // Your user identifier
  session_id: string;   // Conversation session
  wallet_id: string;    // Wallet address (required for WALLET_MODEL)
}

import type { Response, OutputItem, ContentPart } from '@chaoslabs/ai-sdk';
 
interface Response {
  id: string;
  object: 'response';
  model: string;
  status: 'completed' | 'failed';
  output: OutputItem[];
  error?: ResponseError;
}
 
interface OutputItem {
  type: 'message';
  role: 'assistant';
  content: ContentPart[];
}
 
type ContentPart = OutputText | ChaosBlock;

import type {
  Block,
  TableBlock,
  ChartBlock,
  TransactionActionBlock,
  InteractiveBlock,
  MarkdownBlock
} from '@chaoslabs/ai-sdk';
 
type Block =
  | MarkdownBlock
  | TableBlock
  | ChartBlock
  | TransactionActionBlock
  | InteractiveBlock;

import {
  isTableBlock,
  isChartBlock,
  isTransactionActionBlock,
  isInteractiveBlock,
  isMarkdownBlock,
  isOutputText,
  isChaosBlock
} from '@chaoslabs/ai-sdk';
 
// Block type guards
if (isTableBlock(block)) { /* block is TableBlock */ }
if (isChartBlock(block)) { /* block is ChartBlock */ }
if (isTransactionActionBlock(block)) { /* block is TransactionActionBlock */ }
if (isInteractiveBlock(block)) { /* block is InteractiveBlock */ }
if (isMarkdownBlock(block)) { /* block is MarkdownBlock */ }
 
// Content part type guards
if (isOutputText(part)) { /* part is OutputText */ }
if (isChaosBlock(part)) { /* part is ChaosBlock */ }

import {
  extractText,
  extractBlocks,
  hasRisks,
  hasBlockers
} from '@chaoslabs/ai-sdk';
 
// Extract all text content
const text = extractText(response);
 
// Extract all blocks
const blocks = extractBlocks(response);
 
// Check for transaction risks
if (hasBlockers(response)) {
  // High/critical risk - don't execute
}
 
if (hasRisks(response)) {
  // Medium risk - warn user
}

import { ChaosError, ChaosTimeoutError } from '@chaoslabs/ai-sdk';
 
try {
  const response = await chaos.chat.responses.create({...});
} catch (error) {
  if (error instanceof ChaosTimeoutError) {
    // Request timed out
    console.error('Timeout:', error.message);
  } else if (error instanceof ChaosError) {
    // API error
    console.error(`Error ${error.status}: ${error.message}`);
  }
}

import {
  Chaos,
  WALLET_MODEL,
  extractText,
  extractBlocks,
  isTableBlock,
  isChartBlock,
  isTransactionActionBlock,
  hasRisks,
  ChaosError,
  ChaosTimeoutError
} from '@chaoslabs/ai-sdk';
 
const chaos = new Chaos({
  apiKey: process.env.CHAOS_API_KEY!,
  baseUrl: 'https://ai-staging.chaoslabs.co',
});
 
async function queryPortfolio() {
  try {
    const response = await chaos.chat.responses.create({
      model: WALLET_MODEL,
      input: [{ type: 'message', role: 'user', content: "What's in my portfolio?" }],
      metadata: {
        user_id: 'user-123',
        session_id: `session-${Date.now()}`,
        wallet_id: '0xYourWalletAddress',
      },
    });
 
    // Check status
    if (response.status === 'failed') {
      console.error('Failed:', response.error);
      return;
    }
 
    // Get text
    console.log('Response:', extractText(response));
 
    // Process blocks
    const blocks = extractBlocks(response);
 
    for (const block of blocks) {
      if (isTableBlock(block)) {
        console.log(`Table: ${block.title}`);
      }
      if (isChartBlock(block)) {
        console.log(`Chart: ${block.title} (${block.chartType})`);
      }
      if (isTransactionActionBlock(block)) {
        console.log('Action available');
        if (hasRisks(response)) {
          console.log('Warning: Review risks');
        }
      }
    }
  } catch (error) {
    if (error instanceof ChaosTimeoutError) {
      console.error('Request timed out');
    } else if (error instanceof ChaosError) {
      console.error(`API Error: ${error.message}`);
    }
  }
}
 
queryPortfolio();