@chaoslabs/ai-sdk 0.0.1 → 0.0.3

package/dist/schemas.js

@@ -1,143 +1,283 @@
-// Chaos AI SDK V1 - Zod Schemas
-import { z } from "zod";
+// Zod schemas for block validation (match Python backend)
+// Updated to match actual server response structure
+import { z } from 'zod';
 // ============================================================================
-// Client Configuration
+// Block Schemas - Matching Actual Server Response Structure
 // ============================================================================
-export const ChaosConfigSchema = z.object({
-    apiKey: z.string(),
-    baseUrl: z.string().optional(),
-    timeout: z.number().optional(),
-});
-// ============================================================================
-// Request Types
-// ============================================================================
-export const InputItemSchema = z.object({
-    type: z.literal("message"),
-    role: z.enum(["user", "system"]),
+// --- Markdown Block ---
+// Server sends: { content: string } (no type field)
+export const MarkdownBlockSchema = z.object({
     content: z.string(),
 });
-export const RequestMetadataSchema = z.object({
-    user_id: z.string(),
-    session_id: z.string(),
-    wallet_id: z.string().optional(),
-});
-export const CreateResponseParamsSchema = z.object({
-    model: z.string(),
-    input: z.array(InputItemSchema),
-    stream: z.boolean().optional(),
-    metadata: RequestMetadataSchema,
+// --- Table Block ---
+// Server sends: { blockType: "table", ... }
+export const TableColumnTypeSchema = z.enum([
+    'text',
+    'number',
+    'currency',
+    'percentage',
+    'token',
+    'date',
+    'link',
+    'boolean',
+]);
+export const TableSortDirectionSchema = z.enum(['asc', 'desc']);
+export const TableColumnConfigSchema = z.object({
+    type: TableColumnTypeSchema.optional(),
+    sortable: z.boolean().optional(),
+    align: z.enum(['left', 'center', 'right']).optional(),
+    width: z.string().optional(),
 });
-// ============================================================================
-// Block Types
-// ============================================================================
-export const TableCellValueSchema = z.union([z.string(), z.number()]);
 export const TableBlockSchema = z.object({
-    type: z.literal("table"),
+    blockType: z.literal('table'),
     title: z.string(),
     tableHeaders: z.array(z.string()),
-    rows: z.array(z.array(TableCellValueSchema)),
+    tableRows: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))),
+    tableHeadersTypes: z.record(z.string(), z.union([TableColumnTypeSchema, z.literal('currency'), z.literal('percentage')])).optional().nullable(),
+    tableColumnConfigs: z.record(z.string(), TableColumnConfigSchema).optional().nullable(),
+    tableHeadersMetadata: z.record(z.string(), z.object({ type: z.string().optional() }).passthrough()).optional().nullable(),
+    sourceName: z.string().optional().nullable(),
+    defaultSortColumn: z.string().optional().nullable(),
+    defaultSortDirection: TableSortDirectionSchema.optional().nullable(),
+    maxRows: z.number().optional().nullable(),
+    searchable: z.boolean().optional().nullable(),
+    exportable: z.boolean().optional().nullable(),
+    tool_params: z.unknown().optional().nullable(),
+    tool_name: z.string().optional().nullable(),
 });
-export const MarkdownBlockSchema = z.object({
-    type: z.literal("markdown"),
-    content: z.string(),
+// --- Chart Block ---
+// Server sends: { blockType: "chart", data: [[label, value], ...], ... }
+export const ChartDataPointSchema = z.union([
+    z.tuple([z.number(), z.number()]),
+    z.object({ x: z.union([z.number(), z.string()]), y: z.number() }),
+    z.array(z.unknown()),
+]);
+// Array format series item (legacy)
+export const ChartSeriesSchema = z.object({
+    name: z.string(),
+    data: z.array(ChartDataPointSchema),
+    color: z.string().optional(),
+});
+// Timeseries format: server sends series as { "24H": [{ label, data }, ...] }
+export const TimeseriesSeriesItemSchema = z.object({
+    label: z.string(),
+    data: z.array(z.array(z.union([z.number(), z.string()]))), // [[timestamp, value], ...]
 });
-// Primitive params - accepts any JSON-compatible value
-export const PrimitiveParamsSchema = z.record(z.string(), z.unknown());
+// Series can be either:
+// - Array format: [{ name, data, color }, ...]
+// - Object format (timeseries): { "24H": [{ label, data }, ...], "7D": [...] }
+export const ChartSeriesFieldSchema = z.union([
+    z.array(ChartSeriesSchema),
+    z.record(z.string(), z.array(TimeseriesSeriesItemSchema)),
+]);
+export const ChartSegmentSchema = z.object({
+    label: z.string(),
+    value: z.number(),
+    color: z.string().optional(),
+});
+export const ChartAxisSchema = z.object({
+    title: z.string().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    type: z.string().optional(),
+});
+// Legacy data format for pie/donut charts: [[label, value], ...]
+export const ChartLegacyDataSchema = z.array(z.tuple([z.string(), z.number()]));
+export const ChartBlockSchema = z.object({
+    blockType: z.literal('chart'),
+    title: z.string(),
+    chartType: z.enum(['pie', 'donut', 'line', 'area', 'bar', 'timeseries']).optional().nullable(),
+    series: ChartSeriesFieldSchema.nullish(),
+    segments: z.array(ChartSegmentSchema).optional().nullable(),
+    // Legacy data format from server: [[label, value], ...]
+    data: ChartLegacyDataSchema.optional().nullable(),
+    categories: z.array(z.string()).optional().nullable(),
+    xAxis: ChartAxisSchema.optional().nullable(),
+    yAxis: ChartAxisSchema.optional().nullable(),
+    isCurrency: z.boolean().optional().nullable(),
+    sourceName: z.string().optional().nullable(),
+    timeframe: z.string().optional().nullable(),
+    captions: z.array(z.object({ label: z.string(), value: z.string() })).nullish(),
+    titleCryptIcons: z.array(z.object({ name: z.string(), entity: z.string().optional() })).nullish(),
+    tool_params: z.unknown().optional().nullable(),
+    tool_name: z.string().optional().nullable(),
+});
+// --- Transaction Action Block ---
+// Server sends: { blockType: "transaction_action", primitives: [...], transactions: [...], risks: {...}, ... }
+// Primitive display icon
+export const PrimitiveIconSchema = z.object({
+    type: z.string(),
+    value: z.string(),
+});
+// Primitive display line item
+export const PrimitiveLineItemSchema = z.object({
+    label: z.string(),
+    value: z.string(),
+    icon: PrimitiveIconSchema.optional(),
+});
+// Primitive display info
 export const PrimitiveDisplaySchema = z.object({
-    headline: z.string(),
-    amount: z.string().optional(),
+    headline: z.string().optional(),
     action_verb: z.string().optional(),
-    from_asset: z.string().optional(),
-    to_asset: z.string().optional(),
-    from_chain: z.string().optional(),
-    to_chain: z.string().optional(),
-    protocol: z.string().optional(),
-    leverage: z.string().optional(),
-    direction: z.string().optional(),
-    recipient: z.string().optional(),
+    primary_icon: PrimitiveIconSchema.optional(),
+    secondary_icon: PrimitiveIconSchema.optional(),
+    line_items: z.array(PrimitiveLineItemSchema).optional(),
 });
+// Primitive (the actual action like swap, supply, etc.)
 export const PrimitiveSchema = z.object({
     primitive: z.string(),
-    params: PrimitiveParamsSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
     display: PrimitiveDisplaySchema.optional(),
 });
+// Raw transaction data from server
+export const RawTransactionSchema = z.object({
+    to: z.string().optional(),
+    data: z.string().optional(),
+    value: z.string().optional(),
+    chainId: z.number().optional(),
+    description: z.string().optional(),
+    contractName: z.string().optional(),
+    contractVerified: z.boolean().optional(),
+    protocolName: z.string().optional(),
+    contractIcon: z.string().optional(),
+});
+// Transaction group (contains multiple raw transactions)
+export const TransactionGroupSchema = z.object({
+    transactions: z.array(RawTransactionSchema).optional(),
+    requiresApproval: z.boolean().optional(),
+    verificationUnavailable: z.boolean().optional(),
+});
+// Risk impact (quantified risk details)
+export const RiskImpactSchema = z.object({
+    metric: z.string(),
+    current: z.number().nullish(),
+    projected: z.number().nullish(),
+    threshold: z.number().nullish(),
+    at_risk_usd: z.number().nullish(),
+    liquidation_price: z.string().nullish(),
+});
+// Risk check item (used in blockers, warnings, info arrays)
+export const RiskCheckSchema = z.object({
+    id: z.string(),
+    severity: z.enum(['block', 'warn', 'info']),
+    title: z.string(),
+    message: z.string(),
+    impact: RiskImpactSchema.nullish(),
+});
+// Legacy alias for backwards compatibility
+export const RiskInfoItemSchema = RiskCheckSchema;
+// Risks object
 export const RisksSchema = z.object({
-    level: z.enum(["low", "medium", "high", "critical"]),
-    warnings: z.array(z.string()),
-    blockers: z.array(z.string()).optional(),
+    level: z.enum(['low', 'medium', 'high', 'critical']).nullish(),
+    blockers: z.array(RiskCheckSchema).nullish(),
+    warnings: z.array(RiskCheckSchema).nullish(),
+    info: z.array(RiskCheckSchema).nullish(),
 });
 export const TransactionActionBlockSchema = z.object({
-    type: z.literal("transaction_action"),
-    title: z.string(),
-    primitives: z.array(PrimitiveSchema),
+    blockType: z.literal('transaction_action'),
+    value: z.record(z.string(), z.unknown()).optional(),
+    sequence: z.boolean().optional(),
+    primitives: z.array(PrimitiveSchema).optional(),
+    transactions: z.array(TransactionGroupSchema).optional(),
+    needs_confirmation: z.boolean().optional(),
+    notes: z.string().optional(),
     risks: RisksSchema.optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    tool_params: z.unknown().optional().nullable(),
+    tool_name: z.string().optional().nullable(),
 });
+// --- Interactive Block ---
+// Server sends: { blockType: "interactive", title, body?, context?, style?, options? }
+// Note: Using .nullish() to accept both null and undefined (Python sends null for None)
 export const InteractiveOptionSchema = z.object({
     id: z.string(),
     label: z.string(),
-    description: z.string().optional(),
-});
-export const InteractiveCardBlockSchema = z.object({
-    type: z.literal("interactive_card"),
-    title: z.string(),
-    body: z.string().optional(),
-    style: z.enum(["options", "confirm_cancel"]),
-    options: z.array(InteractiveOptionSchema).optional(),
+    description: z.string().nullish(), // Accept null OR undefined
+    metadata: z.record(z.string(), z.unknown()).nullish(),
 });
-export const TimeseriesDataPointSchema = z.tuple([z.number(), z.number()]);
-export const TimeseriesSeriesSchema = z.object({
-    label: z.string(),
-    data: z.array(TimeseriesDataPointSchema),
-});
-export const TimeseriesDataSchema = z.record(z.string(), z.array(TimeseriesSeriesSchema));
-export const TimeseriesBlockSchema = z.object({
-    type: z.literal("timeseries"),
-    title: z.string(),
-    data: TimeseriesDataSchema,
+export const InteractiveBlockSchema = z.object({
+    blockType: z.literal('interactive'),
+    title: z.string(), // Required, matches Python
+    body: z.string().nullish(), // Optional, matches Python
+    context: z.string().nullish(), // Optional, matches Python
+    style: z.enum(['options', 'confirm_cancel']).nullish(),
+    options: z.array(InteractiveOptionSchema).nullish(),
 });
-export const PieChartBlockSchema = z.object({
-    type: z.literal("pie_chart"),
-    title: z.string(),
-    data: z.array(z.tuple([z.string(), z.number()])),
-});
-export const BlockSchema = z.discriminatedUnion("type", [
-    TableBlockSchema,
-    MarkdownBlockSchema,
-    TransactionActionBlockSchema,
-    InteractiveCardBlockSchema,
-    TimeseriesBlockSchema,
-    PieChartBlockSchema,
-]);
 // ============================================================================
-// Response Types
+// Block Detection and Parsing
 // ============================================================================
-export const OutputTextSchema = z.object({
-    type: z.literal("output_text"),
-    text: z.string(),
-});
-export const ChaosBlockSchema = z.object({
-    type: z.literal("chaos.block"),
-    block: BlockSchema,
-});
-export const ContentPartSchema = z.discriminatedUnion("type", [
-    OutputTextSchema,
-    ChaosBlockSchema,
+// Detect block type from raw server data
+export function detectBlockType(raw) {
+    if (!raw || typeof raw !== 'object')
+        return 'unknown';
+    const obj = raw;
+    // Check blockType field first
+    if (obj.blockType === 'table')
+        return 'table';
+    if (obj.blockType === 'chart')
+        return 'chart';
+    if (obj.blockType === 'transaction_action')
+        return 'transaction_action';
+    if (obj.blockType === 'interactive')
+        return 'interactive';
+    // Markdown blocks have no blockType, just content
+    if ('content' in obj && typeof obj.content === 'string' && !('blockType' in obj)) {
+        return 'markdown';
+    }
+    return 'unknown';
+}
+// Parse a raw block based on detected type
+export function parseRawBlock(raw) {
+    const blockType = detectBlockType(raw);
+    switch (blockType) {
+        case 'markdown': {
+            const result = MarkdownBlockSchema.safeParse(raw);
+            if (result.success) {
+                return { success: true, data: { type: 'markdown', ...result.data }, type: 'markdown' };
+            }
+            return { success: false, error: `Markdown parse error: ${result.error.message}` };
+        }
+        case 'table': {
+            const result = TableBlockSchema.safeParse(raw);
+            if (result.success) {
+                return { success: true, data: { type: 'table', ...result.data }, type: 'table' };
+            }
+            return { success: false, error: `Table parse error: ${result.error.message}` };
+        }
+        case 'chart': {
+            const result = ChartBlockSchema.safeParse(raw);
+            if (result.success) {
+                return { success: true, data: { type: 'chart', ...result.data }, type: 'chart' };
+            }
+            return { success: false, error: `Chart parse error: ${result.error.message}` };
+        }
+        case 'transaction_action': {
+            const result = TransactionActionBlockSchema.safeParse(raw);
+            if (result.success) {
+                return { success: true, data: { type: 'transaction_action', ...result.data }, type: 'transaction_action' };
+            }
+            return { success: false, error: `TransactionAction parse error: ${result.error.message}` };
+        }
+        case 'interactive': {
+            const result = InteractiveBlockSchema.safeParse(raw);
+            if (result.success) {
+                return { success: true, data: { type: 'interactive', ...result.data }, type: 'interactive' };
+            }
+            return { success: false, error: `Interactive parse error: ${result.error.message}` };
+        }
+        default:
+            return { success: false, error: `Unknown block type` };
+    }
+}
+// ============================================================================
+// Legacy exports for backwards compatibility
+// ============================================================================
+// Create a discriminated union schema that adds 'type' field
+// This is for SDK consumers who expect 'type' field
+export const BlockSchema = z.union([
+    MarkdownBlockSchema.transform(data => ({ type: 'markdown', ...data })),
+    TableBlockSchema.transform(data => ({ type: 'table', ...data })),
+    ChartBlockSchema.transform(data => ({ type: 'chart', ...data })),
+    TransactionActionBlockSchema.transform(data => ({ type: 'transaction_action', ...data })),
+    InteractiveBlockSchema.transform(data => ({ type: 'interactive', ...data })),
 ]);
-export const OutputItemSchema = z.object({
-    type: z.literal("message"),
-    role: z.literal("assistant"),
-    content: z.array(ContentPartSchema),
-});
-export const ResponseErrorSchema = z.object({
-    message: z.string(),
-    type: z.string(),
-    code: z.string(),
-});
-export const ResponseSchema = z.object({
-    id: z.string(),
-    object: z.literal("response"),
-    model: z.string(),
-    status: z.enum(["completed", "failed"]),
-    output: z.array(OutputItemSchema),
-    error: ResponseErrorSchema.optional(),
-});