@chaoslabs/ai-sdk 0.0.11 → 1.0.0

package/dist/stream.js

@@ -34,7 +34,11 @@ export function parseAgentStatus(msg) {
     if (msg.type !== "agent_status_change") {
         return null;
     }
-    return msg.content.status;
+    const status = msg.content?.status;
+    if (!status || !VALID_STATUSES.includes(status)) {
+        return null;
+    }
+    return status;
 }
 const TERMINAL_STATUSES = ["done", "error", "cancelled"];
 export function isTerminalStatus(status) {
@@ -47,19 +51,19 @@ export function extractAgentMessageText(msg) {
     if (msg.type !== "agent_message") {
         return null;
     }
-    return msg.content.data.message;
+    return msg.content?.data?.message ?? null;
 }
 export function extractSuggestions(msg) {
     if (msg.type !== "follow_up_suggestions") {
         return [];
     }
-    return msg.content.data.followUpQueries;
+    return msg.content?.data?.followUpQueries ?? [];
 }
 export function extractReportBlock(msg) {
     if (msg.type !== "report") {
         return null;
     }
-    return msg.content.data;
+    return msg.content?.data ?? null;
 }
 // ============================================================================
 // Stream Parser

package/dist/type-guards.d.ts

@@ -0,0 +1,316 @@
+import type { Block, ChartBlock, InfoBlock, CodeBlock } from './types.js';
+import type { Primitive, SwapPrimitive, BridgePrimitive, SupplyPrimitive, WithdrawPrimitive, BorrowPrimitive, RepayPrimitive, StakePrimitive, UnstakePrimitive, ClaimPrimitive, AddLiquidityPrimitive, RemoveLiquidityPrimitive, OpenPositionPrimitive, ClosePositionPrimitive, DepositPrimitive, MintPrimitive, BurnPrimitive, RestakePrimitive, ApprovePrimitive, TransferPrimitive, WrapPrimitive, UnwrapPrimitive } from './primitives.js';
+/**
+ * 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 declare function isSwapPrimitive(p: Primitive): p is SwapPrimitive;
+/**
+ * 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 declare function isBridgePrimitive(p: Primitive): p is BridgePrimitive;
+/**
+ * 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 declare function isSupplyPrimitive(p: Primitive): p is SupplyPrimitive;
+/**
+ * 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 declare function isWithdrawPrimitive(p: Primitive): p is WithdrawPrimitive;
+/**
+ * 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 declare function isBorrowPrimitive(p: Primitive): p is BorrowPrimitive;
+/**
+ * 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 declare function isRepayPrimitive(p: Primitive): p is RepayPrimitive;
+/**
+ * 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 declare function isStakePrimitive(p: Primitive): p is StakePrimitive;
+/**
+ * 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 declare function isUnstakePrimitive(p: Primitive): p is UnstakePrimitive;
+/**
+ * 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 declare function isClaimPrimitive(p: Primitive): p is ClaimPrimitive;
+/**
+ * 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 declare function isAddLiquidityPrimitive(p: Primitive): p is AddLiquidityPrimitive;
+/**
+ * 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 declare function isRemoveLiquidityPrimitive(p: Primitive): p is RemoveLiquidityPrimitive;
+/**
+ * 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 declare function isOpenPositionPrimitive(p: Primitive): p is OpenPositionPrimitive;
+/**
+ * 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 declare function isClosePositionPrimitive(p: Primitive): p is ClosePositionPrimitive;
+/**
+ * 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 declare function isDepositPrimitive(p: Primitive): p is DepositPrimitive;
+/**
+ * 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 declare function isMintPrimitive(p: Primitive): p is MintPrimitive;
+/**
+ * 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 declare function isBurnPrimitive(p: Primitive): p is BurnPrimitive;
+/**
+ * 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 declare function isRestakePrimitive(p: Primitive): p is RestakePrimitive;
+/**
+ * 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 declare function isApprovePrimitive(p: Primitive): p is ApprovePrimitive;
+/**
+ * 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 declare function isTransferPrimitive(p: Primitive): p is TransferPrimitive;
+/**
+ * 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 declare function isWrapPrimitive(p: Primitive): p is WrapPrimitive;
+/**
+ * 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 declare function isUnwrapPrimitive(p: Primitive): p is UnwrapPrimitive;
+import type { PieChartBlock, TimeseriesChartBlock } from './types.js';
+export type { PieChartBlock, TimeseriesChartBlock };
+/**
+ * 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 declare function isPieChartBlock(block: ChartBlock): block is PieChartBlock;
+/**
+ * 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 declare function isTimeseriesChartBlock(block: ChartBlock): block is TimeseriesChartBlock;
+/**
+ * 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 declare function isInfoBlock(block: Block): block is InfoBlock;
+/**
+ * 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 declare function isCodeBlock(block: Block): block is CodeBlock;