@chaoslabs/ai-sdk 0.0.10 → 1.0.0

package/dist/type-guards.js

@@ -0,0 +1,373 @@
+// Chaos AI SDK - Type Guards
+//
+// Runtime type guards for narrowing discriminated union types.
+// These enable TypeScript to infer specific types after a check.
+import { PRIMITIVE_SWAP, PRIMITIVE_BRIDGE, PRIMITIVE_SUPPLY, PRIMITIVE_WITHDRAW, PRIMITIVE_BORROW, PRIMITIVE_REPAY, PRIMITIVE_STAKE, PRIMITIVE_UNSTAKE, PRIMITIVE_CLAIM, 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, } from './primitives.js';
+// ============================================================================
+// Primitive Type Guards
+// ============================================================================
+/**
+ * Type guard to check if a primitive is a swap operation.
+ *
+ * @example
+ * ```typescript
+ * if (isSwapPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is SwapParams
+ *   console.log(primitive.params.token_in);
+ *   console.log(primitive.params.token_out);
+ * }
+ * ```
+ */
+export function isSwapPrimitive(p) {
+    return p.primitive === PRIMITIVE_SWAP;
+}
+/**
+ * Type guard to check if a primitive is a bridge operation.
+ *
+ * @example
+ * ```typescript
+ * if (isBridgePrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is BridgeParams
+ *   console.log(primitive.params.from_chain);
+ *   console.log(primitive.params.to_chain);
+ * }
+ * ```
+ */
+export function isBridgePrimitive(p) {
+    return p.primitive === PRIMITIVE_BRIDGE;
+}
+/**
+ * Type guard to check if a primitive is a supply operation.
+ *
+ * @example
+ * ```typescript
+ * if (isSupplyPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LendingParams
+ *   console.log(primitive.params.asset);
+ *   console.log(primitive.params.amount);
+ * }
+ * ```
+ */
+export function isSupplyPrimitive(p) {
+    return p.primitive === PRIMITIVE_SUPPLY;
+}
+/**
+ * Type guard to check if a primitive is a withdraw operation.
+ *
+ * @example
+ * ```typescript
+ * if (isWithdrawPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LendingParams
+ *   console.log(primitive.params.asset);
+ * }
+ * ```
+ */
+export function isWithdrawPrimitive(p) {
+    return p.primitive === PRIMITIVE_WITHDRAW;
+}
+/**
+ * Type guard to check if a primitive is a borrow operation.
+ *
+ * @example
+ * ```typescript
+ * if (isBorrowPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LendingParams
+ *   console.log(primitive.params.asset);
+ * }
+ * ```
+ */
+export function isBorrowPrimitive(p) {
+    return p.primitive === PRIMITIVE_BORROW;
+}
+/**
+ * Type guard to check if a primitive is a repay operation.
+ *
+ * @example
+ * ```typescript
+ * if (isRepayPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LendingParams
+ *   console.log(primitive.params.asset);
+ * }
+ * ```
+ */
+export function isRepayPrimitive(p) {
+    return p.primitive === PRIMITIVE_REPAY;
+}
+/**
+ * Type guard to check if a primitive is a stake operation.
+ *
+ * @example
+ * ```typescript
+ * if (isStakePrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is StakingParams
+ *   console.log(primitive.params.amount);
+ *   console.log(primitive.params.protocol);
+ * }
+ * ```
+ */
+export function isStakePrimitive(p) {
+    return p.primitive === PRIMITIVE_STAKE;
+}
+/**
+ * Type guard to check if a primitive is an unstake operation.
+ *
+ * @example
+ * ```typescript
+ * if (isUnstakePrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is StakingParams
+ *   console.log(primitive.params.amount);
+ * }
+ * ```
+ */
+export function isUnstakePrimitive(p) {
+    return p.primitive === PRIMITIVE_UNSTAKE;
+}
+/**
+ * Type guard to check if a primitive is a claim operation.
+ *
+ * @example
+ * ```typescript
+ * if (isClaimPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is ClaimParams
+ *   console.log(primitive.params.protocol);
+ * }
+ * ```
+ */
+export function isClaimPrimitive(p) {
+    return p.primitive === PRIMITIVE_CLAIM;
+}
+/**
+ * Type guard to check if a primitive is an add liquidity operation.
+ *
+ * @example
+ * ```typescript
+ * if (isAddLiquidityPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LiquidityParams
+ *   console.log(primitive.params.token_a);
+ *   console.log(primitive.params.token_b);
+ * }
+ * ```
+ */
+export function isAddLiquidityPrimitive(p) {
+    return p.primitive === PRIMITIVE_ADD_LIQUIDITY;
+}
+/**
+ * Type guard to check if a primitive is a remove liquidity operation.
+ *
+ * @example
+ * ```typescript
+ * if (isRemoveLiquidityPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is LiquidityParams
+ *   console.log(primitive.params.token_a);
+ * }
+ * ```
+ */
+export function isRemoveLiquidityPrimitive(p) {
+    return p.primitive === PRIMITIVE_REMOVE_LIQUIDITY;
+}
+/**
+ * Type guard to check if a primitive is an open position operation.
+ *
+ * @example
+ * ```typescript
+ * if (isOpenPositionPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is PositionParams
+ *   console.log(primitive.params.market);
+ *   console.log(primitive.params.side);
+ * }
+ * ```
+ */
+export function isOpenPositionPrimitive(p) {
+    return p.primitive === PRIMITIVE_OPEN_POSITION;
+}
+/**
+ * Type guard to check if a primitive is a close position operation.
+ *
+ * @example
+ * ```typescript
+ * if (isClosePositionPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is PositionParams
+ *   console.log(primitive.params.market);
+ * }
+ * ```
+ */
+export function isClosePositionPrimitive(p) {
+    return p.primitive === PRIMITIVE_CLOSE_POSITION;
+}
+/**
+ * Type guard to check if a primitive is a deposit operation.
+ *
+ * @example
+ * ```typescript
+ * if (isDepositPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is DepositParams
+ *   console.log(primitive.params.vault);
+ * }
+ * ```
+ */
+export function isDepositPrimitive(p) {
+    return p.primitive === PRIMITIVE_DEPOSIT;
+}
+/**
+ * Type guard to check if a primitive is a mint operation.
+ *
+ * @example
+ * ```typescript
+ * if (isMintPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is MintParams
+ *   console.log(primitive.params.asset);
+ *   console.log(primitive.params.collateral);
+ * }
+ * ```
+ */
+export function isMintPrimitive(p) {
+    return p.primitive === PRIMITIVE_MINT;
+}
+/**
+ * Type guard to check if a primitive is a burn operation.
+ *
+ * @example
+ * ```typescript
+ * if (isBurnPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is MintParams
+ *   console.log(primitive.params.asset);
+ * }
+ * ```
+ */
+export function isBurnPrimitive(p) {
+    return p.primitive === PRIMITIVE_BURN;
+}
+/**
+ * Type guard to check if a primitive is a restake operation.
+ *
+ * @example
+ * ```typescript
+ * if (isRestakePrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is StakingParams
+ *   console.log(primitive.params.amount);
+ *   console.log(primitive.params.operator);
+ * }
+ * ```
+ */
+export function isRestakePrimitive(p) {
+    return p.primitive === PRIMITIVE_RESTAKE;
+}
+/**
+ * Type guard to check if a primitive is an approve operation.
+ *
+ * @example
+ * ```typescript
+ * if (isApprovePrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is ApproveParams
+ *   console.log(primitive.params.token);
+ *   console.log(primitive.params.spender);
+ * }
+ * ```
+ */
+export function isApprovePrimitive(p) {
+    return p.primitive === PRIMITIVE_APPROVE;
+}
+/**
+ * Type guard to check if a primitive is a transfer operation.
+ *
+ * @example
+ * ```typescript
+ * if (isTransferPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is TransferParams
+ *   console.log(primitive.params.token);
+ *   console.log(primitive.params.to);
+ * }
+ * ```
+ */
+export function isTransferPrimitive(p) {
+    return p.primitive === PRIMITIVE_TRANSFER;
+}
+/**
+ * Type guard to check if a primitive is a wrap operation.
+ *
+ * @example
+ * ```typescript
+ * if (isWrapPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is WrapParams
+ *   console.log(primitive.params.amount);
+ * }
+ * ```
+ */
+export function isWrapPrimitive(p) {
+    return p.primitive === PRIMITIVE_WRAP;
+}
+/**
+ * Type guard to check if a primitive is an unwrap operation.
+ *
+ * @example
+ * ```typescript
+ * if (isUnwrapPrimitive(primitive)) {
+ *   // TypeScript knows primitive.params is WrapParams
+ *   console.log(primitive.params.amount);
+ * }
+ * ```
+ */
+export function isUnwrapPrimitive(p) {
+    return p.primitive === PRIMITIVE_UNWRAP;
+}
+/**
+ * Type guard to check if a chart block is a pie chart.
+ *
+ * @example
+ * ```typescript
+ * if (isPieChartBlock(block)) {
+ *   // TypeScript knows block.chartType is 'pie'
+ *   const data = block.data; // [[label, value], ...]
+ * }
+ * ```
+ */
+export function isPieChartBlock(block) {
+    return block.chartType === 'pie';
+}
+/**
+ * Type guard to check if a chart block is a timeseries chart.
+ *
+ * @example
+ * ```typescript
+ * if (isTimeseriesChartBlock(block)) {
+ *   // TypeScript knows block.chartType is 'timeseries'
+ *   const series = block.series;
+ * }
+ * ```
+ */
+export function isTimeseriesChartBlock(block) {
+    return block.chartType === 'timeseries';
+}
+// ============================================================================
+// Block Type Guards
+// ============================================================================
+/**
+ * Type guard to check if a block is an info block.
+ *
+ * @example
+ * ```typescript
+ * if (isInfoBlock(block)) {
+ *   // TypeScript knows block is InfoBlock
+ *   console.log(block.message);
+ *   console.log(block.severity);
+ * }
+ * ```
+ */
+export function isInfoBlock(block) {
+    return block.type === 'info';
+}
+/**
+ * Type guard to check if a block is a code block.
+ *
+ * @example
+ * ```typescript
+ * if (isCodeBlock(block)) {
+ *   // TypeScript knows block is CodeBlock
+ *   console.log(block.code);
+ *   console.log(block.language);
+ * }
+ * ```
+ */
+export function isCodeBlock(block) {
+    return block.type === 'code';
+}

package/dist/types.d.ts

@@ -11,6 +11,8 @@ export interface ChaosConfig {
     /** Use native http/https modules for streaming instead of fetch (defaults to true) */
     useNativeHttp?: boolean;
 }
+import type { Primitive } from './primitives.js';
+export type { Primitive } from './primitives.js';
 /**
  * Parameters for creating a response.
  */
@@ -42,9 +44,18 @@ export interface CreateResponseParams {
  */
 export interface InputItem {
     type: 'message';
-    role: 'user' | 'system';
+    role: 'user' | 'system' | 'assistant';
     content: string;
 }
+/**
+ * Wallet information for multi-chain support.
+ */
+export interface WalletInfo {
+    /** Wallet address */
+    address: string;
+    /** Chain name (e.g., 'ethereum', 'base', 'solana') */
+    chain: string;
+}
 /**
  * Request metadata including user and session identifiers.
  */
@@ -53,8 +64,8 @@ export interface RequestMetadata {
     user_id: string;
     /** Session identifier for conversation continuity */
     session_id: string;
-    /** Wallet identifier (required for WALLET_MODEL) */
-    wallet_id: string;
+    /** Array of wallet addresses across multiple chains */
+    wallets?: WalletInfo[];
 }
 /**
  * A response from the Chaos API.
@@ -103,55 +114,26 @@ export interface ChaosBlock {
  * Union of all block types.
  * Note: SDK adds 'type' field for consistency, server uses 'blockType'.
  */
-export type Block = MarkdownBlock | TableBlock | ChartBlock | TransactionActionBlock | InteractiveBlock;
+export type Block = MarkdownBlock | TableBlock | ChartBlock | PieChartBlock | TimeseriesChartBlock | TransactionActionBlock | InteractiveBlock | InfoBlock | CodeBlock;
 /**
  * Markdown content block.
  * Server sends: { content: string } (no blockType)
  */
 export interface MarkdownBlock {
     type: 'markdown';
+    blockType: 'markdown';
     content: string;
 }
-/**
- * Table column type.
- */
-export type TableColumnType = 'text' | 'number' | 'currency' | 'percentage' | 'token' | 'date' | 'link' | 'boolean';
-/**
- * Table sort direction.
- */
-export type TableSortDirection = 'asc' | 'desc';
-/**
- * Table column configuration.
- */
-export interface TableColumnConfig {
-    type?: TableColumnType;
-    sortable?: boolean;
-    align?: 'left' | 'center' | 'right';
-    width?: string;
-}
 /**
  * Table visualization block.
- * Server sends: { blockType: "table", ... }
  */
 export interface TableBlock {
     type: 'table';
-    blockType?: 'table';
-    title: string;
+    blockType: 'table';
+    title?: string;
     tableHeaders: string[];
-    tableRows: Array<Array<string | number | boolean | null>>;
-    tableHeadersTypes?: Record<string, TableColumnType | 'currency' | 'percentage'> | null;
-    tableColumnConfigs?: Record<string, TableColumnConfig> | null;
-    tableHeadersMetadata?: Record<string, {
-        type?: string;
-    }> | null;
-    sourceName?: string | null;
-    defaultSortColumn?: string | null;
-    defaultSortDirection?: TableSortDirection | null;
-    maxRows?: number | null;
-    searchable?: boolean | null;
-    exportable?: boolean | null;
-    tool_params?: unknown;
-    tool_name?: string | null;
+    tableRows: Array<Array<unknown>>;
+    tableHeadersMetadata?: Record<string, Record<string, unknown>>;
 }
 /**
  * Chart series data point.
@@ -189,66 +171,44 @@ export interface ChartAxis {
  * Chart visualization block.
  * Server sends: { blockType: "chart", data: [[label, value], ...], ... }
  */
-export interface ChartBlock {
-    type: 'chart';
-    blockType?: 'chart';
-    title: string;
-    chartType?: 'pie' | 'donut' | 'line' | 'area' | 'bar' | 'timeseries' | null;
-    series?: ChartSeries[] | null;
-    segments?: ChartSegment[] | null;
-    /** Legacy data format from server: [[label, value], ...] */
-    data?: Array<[string, number]> | null;
-    categories?: string[] | null;
-    xAxis?: ChartAxis | null;
-    yAxis?: ChartAxis | null;
-    isCurrency?: boolean | null;
-    sourceName?: string | null;
-    timeframe?: string | null;
-    tool_params?: unknown;
-    tool_name?: string | null;
-}
-/**
- * Icon for primitive display.
- */
-export interface PrimitiveIcon {
-    type: string;
-    value: string;
-}
-/**
- * Line item for primitive display.
- */
-export interface PrimitiveLineItem {
-    label: string;
-    value: string;
-    icon?: PrimitiveIcon;
-}
+export type ChartBlock = PieChartBlock | TimeseriesChartBlock;
 /**
- * Display information for a primitive.
+ * Pie chart visualization block.
  */
-export interface PrimitiveDisplay {
-    headline?: string;
-    action_verb?: string;
-    primary_icon?: PrimitiveIcon;
-    secondary_icon?: PrimitiveIcon;
-    line_items?: PrimitiveLineItem[];
+export interface PieChartBlock {
+    type: 'chart';
+    blockType: 'chart';
+    chartType: 'pie';
+    title?: string;
+    data: Array<[string, number]>;
+    isCurrency?: boolean;
 }
 /**
- * A primitive action (swap, supply, borrow, etc.)
+ * Timeseries chart visualization block.
  */
-export interface Primitive {
-    primitive: string;
-    params?: Record<string, unknown>;
-    display?: PrimitiveDisplay;
+export interface TimeseriesChartBlock {
+    type: 'chart';
+    blockType: 'chart';
+    chartType: 'timeseries';
+    title?: string;
+    series: Record<string, Array<{
+        timestamp: number;
+        value: number;
+    }>>;
+    captions?: Array<Record<string, unknown>>;
+    titleCryptoIcons?: Array<Record<string, unknown>>;
+    isCurrency?: boolean;
 }
 /**
  * Raw transaction data from server.
  */
 export interface RawTransaction {
-    to?: string;
-    data?: string;
-    value?: string;
-    chainId?: number;
-    description?: string;
+    to: string;
+    data: string;
+    value: string;
+    chainId: number;
+    gasEstimate?: number;
+    description: string;
     contractName?: string;
     contractVerified?: boolean;
     protocolName?: string;
@@ -258,8 +218,9 @@ export interface RawTransaction {
  * Group of transactions.
  */
 export interface TransactionGroup {
-    transactions?: RawTransaction[];
-    requiresApproval?: boolean;
+    primitive: string;
+    transactions: RawTransaction[];
+    requiresApproval: boolean;
     verificationUnavailable?: boolean;
 }
 /**
@@ -267,7 +228,7 @@ export interface TransactionGroup {
  */
 export interface RiskInfoItem {
     id?: string;
-    severity?: 'info' | 'warning' | 'error' | 'critical';
+    severity?: 'block' | 'warn' | 'info';
     title?: string;
     message?: string;
 }
@@ -275,9 +236,9 @@ export interface RiskInfoItem {
  * Risk assessment for a transaction.
  */
 export interface Risks {
-    level?: string;
-    blockers?: string[];
-    warnings?: string[];
+    level?: 'low' | 'medium' | 'high' | 'critical';
+    blockers?: RiskInfoItem[];
+    warnings?: RiskInfoItem[];
     info?: RiskInfoItem[];
 }
 /**
@@ -285,18 +246,17 @@ export interface Risks {
  * Server sends: { blockType: "transaction_action", primitives: [...], ... }
  */
 export interface TransactionActionBlock {
-    type: 'transaction_action';
-    blockType?: 'transaction_action';
-    value?: Record<string, unknown>;
+    type: 'action';
+    blockType: 'transaction_action';
+    metadata: Record<string, unknown>;
+    needs_confirmation: boolean;
+    notes: string;
+    primitives: Primitive[];
+    references?: string[];
+    risks: Risks;
     sequence?: boolean;
-    primitives?: Primitive[];
     transactions?: TransactionGroup[];
-    needs_confirmation?: boolean;
-    notes?: string;
-    risks?: Risks;
-    metadata?: Record<string, unknown>;
-    tool_params?: unknown;
-    tool_name?: string | null;
+    value?: Record<string, unknown>;
 }
 /**
  * Interactive option.
@@ -305,19 +265,36 @@ export interface InteractiveOption {
     id: string;
     label: string;
     description?: string;
-    value?: unknown;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Interactive block for user input.
- * Server sends: { blockType: "interactive", ... }
  */
 export interface InteractiveBlock {
     type: 'interactive';
-    blockType?: 'interactive';
-    prompt?: string;
+    blockType: 'interactive';
+    title: string;
+    body?: string;
+    context?: string;
+    style: 'options' | 'confirm_cancel';
     options?: InteractiveOption[];
-    allowCustom?: boolean;
-    multiSelect?: boolean;
+}
+/**
+ * Info block for displaying informational messages.
+ */
+export interface InfoBlock {
+    type: 'info';
+    content: string;
+    error?: string | null;
+}
+/**
+ * Code block for displaying formatted code.
+ */
+export interface CodeBlock {
+    type: 'code';
+    blockType: 'code';
+    content: string;
+    language: string;
 }
 /**
  * Error information in a response.

package/dist/types.js

@@ -43,7 +43,7 @@ export function isMarkdownBlock(block) {
  * Check if a block is a transaction action block.
  */
 export function isTransactionActionBlock(block) {
-    return block.type === 'transaction_action';
+    return block.type === 'action';
 }
 /**
  * Check if a block is an interactive block.
@@ -114,6 +114,7 @@ export function hasBlockers(response) {
     const blocks = extractBlocks(response);
     return blocks.some((block) => isTransactionActionBlock(block) &&
         block.risks &&
-        ((block.risks.level === 'high' || block.risks.level === 'critical') ||
+        (block.risks.level === 'high' ||
+            block.risks.level === 'critical' ||
             (block.risks.blockers && block.risks.blockers.length > 0)));
 }