@chaoslabs/ai-sdk 0.0.10 → 1.0.0

package/dist/primitives.d.ts

@@ -155,3 +155,461 @@ export declare function isLiquidityPrimitive(primitive: string): boolean;
  * Check if a primitive is a transfer operation.
  */
 export declare function isTransferPrimitive(primitive: string): boolean;
+/**
+ * Parameters for a swap operation.
+ * @example
+ * ```typescript
+ * const params: SwapParams = {
+ *   token_in: 'ETH',
+ *   token_out: 'USDC',
+ *   amount_in: '1.0',
+ *   slippage: 0.5
+ * };
+ * ```
+ */
+export interface SwapParams {
+    /** Token to swap from */
+    token_in: string;
+    /** Token to swap to */
+    token_out: string;
+    /** Amount of input token to swap */
+    amount_in?: string;
+    /** Exact amount of output token desired */
+    amount_out?: string;
+    /** Maximum slippage tolerance as percentage (e.g., 0.5 for 0.5%) */
+    slippage?: number;
+    /** DEX or aggregator to use */
+    protocol?: string;
+}
+/**
+ * Parameters for a bridge operation.
+ * @example
+ * ```typescript
+ * const params: BridgeParams = {
+ *   asset: 'USDC',
+ *   amount: '100',
+ *   from_chain: 'ethereum',
+ *   to_chain: 'arbitrum'
+ * };
+ * ```
+ */
+export interface BridgeParams {
+    /** Asset to bridge */
+    asset: string;
+    /** Amount to bridge */
+    amount: string;
+    /** Source chain */
+    from_chain: string;
+    /** Destination chain */
+    to_chain: string;
+    /** Recipient address on destination chain (defaults to sender) */
+    recipient?: string;
+    /** Bridge protocol to use */
+    protocol?: string;
+}
+/**
+ * Parameters for lending operations (supply, withdraw, borrow, repay).
+ * @example
+ * ```typescript
+ * const params: LendingParams = {
+ *   asset: 'USDC',
+ *   amount: '1000',
+ *   protocol: 'aave'
+ * };
+ * ```
+ */
+export interface LendingParams {
+    /** Asset to supply/withdraw/borrow/repay */
+    asset: string;
+    /** Amount of asset */
+    amount: string;
+    /** Lending protocol (e.g., 'aave', 'compound', 'morpho') */
+    protocol?: string;
+    /** Interest rate mode for borrow (1 = stable, 2 = variable) */
+    interest_rate_mode?: number;
+}
+/**
+ * Parameters for staking operations (stake, unstake, restake).
+ * @example
+ * ```typescript
+ * const params: StakingParams = {
+ *   amount: '10',
+ *   protocol: 'lido'
+ * };
+ * ```
+ */
+export interface StakingParams {
+    /** Amount to stake/unstake */
+    amount: string;
+    /** Staking protocol (e.g., 'lido', 'rocketpool', 'eigenlayer') */
+    protocol?: string;
+    /** Operator address for delegation (restaking) */
+    operator?: string;
+}
+/**
+ * Parameters for claiming rewards.
+ * @example
+ * ```typescript
+ * const params: ClaimParams = {
+ *   protocol: 'aave',
+ *   assets: ['USDC', 'DAI']
+ * };
+ * ```
+ */
+export interface ClaimParams {
+    /** Protocol to claim from */
+    protocol?: string;
+    /** Specific assets to claim rewards for */
+    assets?: string[];
+}
+/**
+ * Parameters for liquidity operations (add/remove liquidity).
+ * @example
+ * ```typescript
+ * const params: LiquidityParams = {
+ *   token_a: 'ETH',
+ *   token_b: 'USDC',
+ *   amount_a: '1.0',
+ *   amount_b: '2000'
+ * };
+ * ```
+ */
+export interface LiquidityParams {
+    /** First token in the pair */
+    token_a: string;
+    /** Second token in the pair */
+    token_b: string;
+    /** Amount of first token */
+    amount_a?: string;
+    /** Amount of second token */
+    amount_b?: string;
+    /** Percentage of position to remove (for remove_liquidity) */
+    percentage?: number;
+    /** Pool fee tier (e.g., 0.3 for 0.3%) */
+    fee_tier?: number;
+    /** DEX protocol */
+    protocol?: string;
+}
+/**
+ * Parameters for perpetual position operations.
+ * @example
+ * ```typescript
+ * const params: PositionParams = {
+ *   market: 'ETH-PERP',
+ *   side: 'long',
+ *   size: '1.0',
+ *   leverage: 2
+ * };
+ * ```
+ */
+export interface PositionParams {
+    /** Market identifier (e.g., 'ETH-PERP') */
+    market: string;
+    /** Position side: 'long' or 'short' */
+    side?: 'long' | 'short';
+    /** Position size */
+    size?: string;
+    /** Leverage multiplier */
+    leverage?: number;
+    /** Percentage of position to close */
+    percentage?: number;
+    /** Perpetuals protocol */
+    protocol?: string;
+}
+/**
+ * Parameters for vault deposit operations.
+ * @example
+ * ```typescript
+ * const params: DepositParams = {
+ *   vault: 'yearn-usdc',
+ *   amount: '1000'
+ * };
+ * ```
+ */
+export interface DepositParams {
+    /** Vault identifier */
+    vault: string;
+    /** Amount to deposit */
+    amount: string;
+    /** Vault protocol */
+    protocol?: string;
+}
+/**
+ * Parameters for minting operations (e.g., minting stablecoins).
+ * @example
+ * ```typescript
+ * const params: MintParams = {
+ *   asset: 'DAI',
+ *   amount: '1000',
+ *   collateral: 'ETH'
+ * };
+ * ```
+ */
+export interface MintParams {
+    /** Asset to mint */
+    asset: string;
+    /** Amount to mint */
+    amount: string;
+    /** Collateral asset */
+    collateral?: string;
+    /** Protocol (e.g., 'maker') */
+    protocol?: string;
+}
+/**
+ * Parameters for token approval operations.
+ * @example
+ * ```typescript
+ * const params: ApproveParams = {
+ *   token: 'USDC',
+ *   spender: '0x1234...',
+ *   amount: '1000'
+ * };
+ * ```
+ */
+export interface ApproveParams {
+    /** Token to approve */
+    token: string;
+    /** Spender address */
+    spender: string;
+    /** Amount to approve (omit for unlimited) */
+    amount?: string;
+}
+/**
+ * Parameters for token transfer operations.
+ * @example
+ * ```typescript
+ * const params: TransferParams = {
+ *   token: 'USDC',
+ *   to: '0x1234...',
+ *   amount: '100'
+ * };
+ * ```
+ */
+export interface TransferParams {
+    /** Token to transfer */
+    token: string;
+    /** Recipient address */
+    to: string;
+    /** Amount to transfer */
+    amount: string;
+}
+/**
+ * Parameters for wrap/unwrap operations (e.g., ETH to WETH).
+ * @example
+ * ```typescript
+ * const params: WrapParams = {
+ *   amount: '1.0'
+ * };
+ * ```
+ */
+export interface WrapParams {
+    /** Amount to wrap/unwrap */
+    amount: string;
+}
+/**
+ * Icon for primitive display.
+ */
+export interface PrimitiveIcon {
+    type: 'url' | 'icon_id';
+    value: string;
+}
+/**
+ * Line item for primitive display.
+ */
+export interface PrimitiveLineItem {
+    label: string;
+    value: string;
+    icon?: PrimitiveIcon;
+}
+/**
+ * Display information for a primitive.
+ */
+export interface PrimitiveDisplay {
+    headline?: string;
+    action_verb?: string;
+    primary_icon?: PrimitiveIcon;
+    secondary_icon?: PrimitiveIcon;
+    line_items?: PrimitiveLineItem[];
+}
+/**
+ * Base structure for a typed primitive with display info.
+ */
+interface TypedPrimitiveBase {
+    /** Display information for UI rendering */
+    display?: PrimitiveDisplay;
+}
+/**
+ * Swap primitive with typed params.
+ */
+export interface SwapPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_SWAP;
+    params: SwapParams;
+}
+/**
+ * Bridge primitive with typed params.
+ */
+export interface BridgePrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_BRIDGE;
+    params: BridgeParams;
+}
+/**
+ * Supply primitive with typed params.
+ */
+export interface SupplyPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_SUPPLY;
+    params: LendingParams;
+}
+/**
+ * Withdraw primitive with typed params.
+ */
+export interface WithdrawPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_WITHDRAW;
+    params: LendingParams;
+}
+/**
+ * Borrow primitive with typed params.
+ */
+export interface BorrowPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_BORROW;
+    params: LendingParams;
+}
+/**
+ * Repay primitive with typed params.
+ */
+export interface RepayPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_REPAY;
+    params: LendingParams;
+}
+/**
+ * Stake primitive with typed params.
+ */
+export interface StakePrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_STAKE;
+    params: StakingParams;
+}
+/**
+ * Unstake primitive with typed params.
+ */
+export interface UnstakePrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_UNSTAKE;
+    params: StakingParams;
+}
+/**
+ * Claim primitive with typed params.
+ */
+export interface ClaimPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_CLAIM;
+    params: ClaimParams;
+}
+/**
+ * Add liquidity primitive with typed params.
+ */
+export interface AddLiquidityPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_ADD_LIQUIDITY;
+    params: LiquidityParams;
+}
+/**
+ * Remove liquidity primitive with typed params.
+ */
+export interface RemoveLiquidityPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_REMOVE_LIQUIDITY;
+    params: LiquidityParams;
+}
+/**
+ * Open position primitive with typed params.
+ */
+export interface OpenPositionPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_OPEN_POSITION;
+    params: PositionParams;
+}
+/**
+ * Close position primitive with typed params.
+ */
+export interface ClosePositionPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_CLOSE_POSITION;
+    params: PositionParams;
+}
+/**
+ * Deposit primitive with typed params.
+ */
+export interface DepositPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_DEPOSIT;
+    params: DepositParams;
+}
+/**
+ * Mint primitive with typed params.
+ */
+export interface MintPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_MINT;
+    params: MintParams;
+}
+/**
+ * Burn primitive with typed params.
+ */
+export interface BurnPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_BURN;
+    params: MintParams;
+}
+/**
+ * Restake primitive with typed params.
+ */
+export interface RestakePrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_RESTAKE;
+    params: StakingParams;
+}
+/**
+ * Approve primitive with typed params.
+ */
+export interface ApprovePrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_APPROVE;
+    params: ApproveParams;
+}
+/**
+ * Transfer primitive with typed params.
+ */
+export interface TransferPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_TRANSFER;
+    params: TransferParams;
+}
+/**
+ * Wrap primitive with typed params.
+ */
+export interface WrapPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_WRAP;
+    params: WrapParams;
+}
+/**
+ * Unwrap primitive with typed params.
+ */
+export interface UnwrapPrimitive extends TypedPrimitiveBase {
+    primitive: typeof PRIMITIVE_UNWRAP;
+    params: WrapParams;
+}
+/**
+ * Fallback for unknown primitive types.
+ * This ensures forward compatibility when new primitives are added.
+ */
+export interface UnknownPrimitive extends TypedPrimitiveBase {
+    primitive: string;
+    params: Record<string, unknown>;
+}
+/**
+ * Discriminated union of all typed primitives.
+ *
+ * Use type guards to narrow to specific primitive types and access
+ * typed params:
+ *
+ * @example
+ * ```typescript
+ * import { isSwapPrimitive } from '@chaoslabs/ai-sdk';
+ *
+ * function handlePrimitive(p: TypedPrimitive) {
+ *   if (isSwapPrimitive(p)) {
+ *     // TypeScript knows p.params is SwapParams
+ *     console.log(`Swapping ${p.params.token_in} for ${p.params.token_out}`);
+ *   }
+ * }
+ * ```
+ */
+export type Primitive = SwapPrimitive | BridgePrimitive | SupplyPrimitive | WithdrawPrimitive | BorrowPrimitive | RepayPrimitive | StakePrimitive | UnstakePrimitive | ClaimPrimitive | AddLiquidityPrimitive | RemoveLiquidityPrimitive | OpenPositionPrimitive | ClosePositionPrimitive | DepositPrimitive | MintPrimitive | BurnPrimitive | RestakePrimitive | ApprovePrimitive | TransferPrimitive | WrapPrimitive | UnwrapPrimitive | UnknownPrimitive;
+export {};

package/dist/primitives.js

@@ -5,6 +5,7 @@
 // ============================================================================
 // Primitive Type Constants
 // ============================================================================
+// import type { PrimitiveDisplay } from './types.js';
 /**
  * Swap tokens on a decentralized exchange.
  * @example "Swap 1 ETH for USDC"

package/dist/request.d.ts

@@ -1,21 +1,26 @@
-import type { CreateResponseParams } from './types.js';
+import type { CreateResponseParams, WalletInfo } from './types.js';
 /** Model ID for wallet mode (v1 API) */
 export declare const WALLET_MODEL = "WALLET_MODEL";
 /** Model ID for ask mode (v1 API) */
 export declare const ASK_MODEL = "ASK_MODEL";
 /**
- * V1 API request body for wallet mode.
+ * Message format for previous_messages array.
+ */
+export interface PreviousMessage {
+    type: 'message';
+    role: 'user' | 'assistant';
+    content: string;
+}
+/**
+ * V1 API request body for wallet mode with multi-wallet support.
  */
 export interface V1WalletRequest {
     model: string;
     query: string;
     user_id: string;
     session_id: string;
-    wallet_id: string;
-    prior_messages?: {
-        role: string;
-        content: string;
-    }[];
+    wallets?: WalletInfo[];
+    previous_messages?: PreviousMessage[];
 }
 /**
  * V1 API request body for ask mode.
@@ -25,13 +30,10 @@ export interface V1AskRequest {
     query: string;
     user_id: string;
     session_id: string;
-    prior_messages?: {
-        role: string;
-        content: string;
-    }[];
+    previous_messages?: PreviousMessage[];
 }
 /**
- * Transform SDK request to v1 wallet format.
+ * Transform SDK request to v1 wallet format with multi-wallet support.
  */
 export declare function toV1WalletRequest(params: CreateResponseParams, sessionId: string): V1WalletRequest;
 /**

package/dist/request.js

@@ -10,18 +10,18 @@ export const ASK_MODEL = 'ASK_MODEL';
 // Request Builders
 // ============================================================================
 /**
- * Transform SDK request to v1 wallet format.
+ * Transform SDK request to v1 wallet format with multi-wallet support.
  */
 export function toV1WalletRequest(params, sessionId) {
     const query = extractQuery(params.input);
-    const priorMessages = extractPriorMessages(params.input);
+    const previousMessages = extractPriorMessages(params.input);
     return {
         model: params.model,
         query,
         user_id: params.metadata.user_id,
         session_id: sessionId,
-        wallet_id: params.metadata.wallet_id || '',
-        prior_messages: priorMessages.length > 0 ? priorMessages : undefined,
+        ...(params.metadata.wallets && { wallets: params.metadata.wallets }),
+        previous_messages: previousMessages.length > 0 ? previousMessages : undefined,
     };
 }
 /**
@@ -29,13 +29,13 @@ export function toV1WalletRequest(params, sessionId) {
  */
 export function toV1AskRequest(params, sessionId) {
     const query = extractQuery(params.input);
-    const priorMessages = extractPriorMessages(params.input);
+    const previousMessages = extractPriorMessages(params.input);
     return {
         model: params.model,
         query,
         user_id: params.metadata.user_id,
         session_id: sessionId,
-        prior_messages: priorMessages.length > 0 ? priorMessages : undefined,
+        previous_messages: previousMessages.length > 0 ? previousMessages : undefined,
     };
 }
 // ============================================================================
@@ -59,18 +59,48 @@ function extractPriorMessages(input) {
     const messages = [];
     let lastUserIndex = -1;
     for (let i = input.length - 1; i >= 0; i--) {
-        if (input[i].role === 'user') {
+        const item = input[i];
+        // Find the last actual user message (not an assistant message)
+        if (item.role === 'user' && !item.content.startsWith('[Assistant]: ')) {
             lastUserIndex = i;
             break;
         }
     }
     for (let i = 0; i < lastUserIndex; i++) {
         const item = input[i];
-        if (item.type === 'message' && (item.role === 'user' || item.role === 'system')) {
-            messages.push({
-                role: item.role === 'system' ? 'system' : item.role,
-                content: item.content,
-            });
+        if (item.type === 'message') {
+            // Handle assistant role directly
+            if (item.role === 'assistant') {
+                messages.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content: item.content,
+                });
+            }
+            // Also support legacy format with [Assistant]: prefix
+            else if (item.content.startsWith('[Assistant]: ')) {
+                messages.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content: item.content.replace('[Assistant]: ', ''),
+                });
+            }
+            // Regular user message
+            else if (item.role === 'user') {
+                messages.push({
+                    type: 'message',
+                    role: 'user',
+                    content: item.content,
+                });
+            }
+            // System messages (if needed for special instructions)
+            else if (item.role === 'system') {
+                messages.push({
+                    type: 'message',
+                    role: 'user',
+                    content: item.content,
+                });
+            }
         }
     }
     return messages;

package/dist/response.js

@@ -76,33 +76,24 @@ function parseBlock(rawBlock) {
     const result = parseRawBlock(rawBlock);
     if (result.success) {
         const block = result.data;
-        // Transform legacy chart data format to segments
+        // Transform legacy chart data format - clean up null values for cleaner API
         if (block.type === 'chart') {
             const chartBlock = block;
-            // If server sent data as [[label, value], ...] but not segments, convert it
-            if (chartBlock.data && (!chartBlock.segments || chartBlock.segments.length === 0)) {
-                chartBlock.segments = chartBlock.data.map(([label, value]) => ({
-                    label,
-                    value,
-                }));
+            // Clean up null to undefined for optional fields
+            if (chartBlock.chartType === 'pie') {
+                const pieBlock = chartBlock;
+                if (pieBlock.isCurrency === null)
+                    pieBlock.isCurrency = undefined;
+            }
+            else if (chartBlock.chartType === 'timeseries') {
+                const timeseriesBlock = chartBlock;
+                if (timeseriesBlock.captions === null)
+                    timeseriesBlock.captions = undefined;
+                if (timeseriesBlock.titleCryptoIcons === null)
+                    timeseriesBlock.titleCryptoIcons = undefined;
+                if (timeseriesBlock.isCurrency === null)
+                    timeseriesBlock.isCurrency = undefined;
             }
-            // Clean up null values for cleaner API
-            if (chartBlock.segments === null)
-                chartBlock.segments = undefined;
-            if (chartBlock.series === null)
-                chartBlock.series = undefined;
-            if (chartBlock.categories === null)
-                chartBlock.categories = undefined;
-            if (chartBlock.xAxis === null)
-                chartBlock.xAxis = undefined;
-            if (chartBlock.yAxis === null)
-                chartBlock.yAxis = undefined;
-            if (chartBlock.sourceName === null)
-                chartBlock.sourceName = undefined;
-            if (chartBlock.timeframe === null)
-                chartBlock.timeframe = undefined;
-            if (chartBlock.isCurrency === null)
-                chartBlock.isCurrency = undefined;
         }
         return block;
     }