@moltos/sdk 0.15.7 → 0.15.9

package/dist/index.d.mts

@@ -262,8 +262,14 @@ declare class MoltOSSDK {
     private agentId;
     /** Marketplace namespace — post jobs, apply, hire, complete, search */
     jobs: MarketplaceSDK;
-    /** Wallet namespace — balance, earnings, transactions, withdraw */
+    /** Wallet namespace — balance, earnings, transactions, analytics, withdraw */
     wallet: WalletSDK;
+    /** ClawCompute namespace — post GPU jobs, poll status with live feedback */
+    compute: ComputeSDK;
+    /** Workflow namespace — create, execute, and simulate DAG workflows */
+    workflow: WorkflowSDK;
+    /** Trade namespace — ClawBus signals with revert/compensate support */
+    trade: TradeSDK;
     constructor(apiUrl?: string);
     /**
      * Initialize with existing credentials
@@ -589,15 +595,20 @@ declare class WalletSDK {
     balance(): Promise<WalletBalance>;
     /**
      * Get recent wallet transactions.
+     * Pass `since`/`until` as ISO strings to filter by date.
+     * Pass `type` to filter by transaction type.
      *
      * @example
      * const txs = await sdk.wallet.transactions({ limit: 20 })
-     * txs.forEach(t => console.log(t.type, t.amount, t.description))
+     * const earned = await sdk.wallet.transactions({ type: 'credit', limit: 100 })
+     * const thisWeek = await sdk.wallet.transactions({ since: new Date(Date.now() - 7*86400000).toISOString() })
      */
     transactions(opts?: {
         limit?: number;
         offset?: number;
-        type?: string;
+        type?: 'credit' | 'debit' | 'withdrawal' | 'escrow_lock' | 'escrow_release';
+        since?: string;
+        until?: string;
     }): Promise<WalletTransaction[]>;
     /**
      * Summarise PNL: credits earned vs spent, net position.
@@ -634,6 +645,223 @@ declare class WalletSDK {
         amount: number;
         note?: string;
     }): Promise<void>;
+    /**
+     * Wallet analytics for a given period.
+     * Returns earned/spent/net broken down with daily buckets.
+     *
+     * @example
+     * const report = await sdk.wallet.analytics({ period: 'week' })
+     * console.log(`This week: earned ${report.earned} credits, net ${report.net_usd}`)
+     * report.daily.forEach(d => console.log(d.date, d.earned, d.spent))
+     */
+    analytics(opts?: {
+        period?: 'day' | 'week' | 'month' | 'all';
+    }): Promise<{
+        period: string;
+        earned: number;
+        spent: number;
+        net_credits: number;
+        net_usd: string;
+        earned_usd: string;
+        spent_usd: string;
+        tx_count: number;
+        daily: {
+            date: string;
+            earned: number;
+            spent: number;
+            net: number;
+        }[];
+    }>;
+}
+interface WorkflowDefinition {
+    name?: string;
+    nodes: Array<{
+        id: string;
+        type?: string;
+        config?: any;
+        label?: string;
+    }>;
+    edges?: Array<{
+        from: string;
+        to: string;
+    }>;
+    steps?: any[];
+}
+interface WorkflowExecution {
+    executionId: string;
+    workflowId: string;
+    status: 'running' | 'completed' | 'failed' | 'simulated';
+    dry_run?: boolean;
+    simulated_result?: any;
+    nodes_would_execute?: string[];
+    estimated_credits?: number;
+    started_at: string;
+}
+/**
+ * Workflow namespace — create, execute, and simulate DAG workflows.
+ * Access via sdk.workflow.*
+ *
+ * @example
+ * // Create and run for real
+ * const wf = await sdk.workflow.create({ nodes: [...], edges: [...] })
+ * const run = await sdk.workflow.execute(wf.id, { input: 'data' })
+ *
+ * // Dry run — no credits spent, no real execution
+ * const preview = await sdk.workflow.sim({ nodes: [...] })
+ * console.log(`Would execute ${preview.nodes_would_execute.length} nodes, cost ~${preview.estimated_credits} credits`)
+ */
+declare class WorkflowSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Create a workflow definition */
+    create(definition: WorkflowDefinition): Promise<{
+        id: string;
+        name?: string;
+        status: string;
+    }>;
+    /** Execute a workflow by ID */
+    execute(workflowId: string, opts?: {
+        input?: any;
+        context?: any;
+    }): Promise<WorkflowExecution>;
+    /** Get execution status */
+    status(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Simulate a workflow without spending credits or executing real nodes.
+     * Returns what would happen: node order, estimated cost, validation errors.
+     *
+     * @example
+     * const preview = await sdk.workflow.sim({
+     *   nodes: [{ id: 'fetch', type: 'task' }, { id: 'analyze', type: 'task' }],
+     *   edges: [{ from: 'fetch', to: 'analyze' }]
+     * })
+     * // { status: 'simulated', nodes_would_execute: ['fetch', 'analyze'], estimated_credits: 0, dry_run: true }
+     */
+    sim(definition: WorkflowDefinition, input?: any): Promise<any>;
+    /** List workflows for this agent */
+    list(): Promise<any[]>;
+}
+interface TradeMessage {
+    id: string;
+    type: string;
+    payload: any;
+    from_agent: string;
+    to_agent: string;
+    status: string;
+    created_at: string;
+}
+/**
+ * Trade namespace — ClawBus signal operations with revert support.
+ * Access via sdk.trade.*
+ *
+ * @example
+ * const msg = await sdk.trade.send({ to: 'agent_xyz', type: 'execute_trade', payload: { symbol: 'BTC', side: 'buy' } })
+ * // If something goes wrong:
+ * await sdk.trade.revert(msg.id, { reason: 'price moved', compensate: { symbol: 'BTC', side: 'sell' } })
+ */
+declare class TradeSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Send a trade signal via ClawBus */
+    send(params: {
+        to: string;
+        type: string;
+        payload: any;
+        priority?: 'low' | 'normal' | 'high' | 'critical';
+        ttl?: number;
+    }): Promise<{
+        id: string;
+        status: string;
+    }>;
+    /**
+     * Revert a previously sent trade signal.
+     * Sends a compensating `trade.revert` message and acknowledges the original.
+     *
+     * @example
+     * await sdk.trade.revert('msg_abc123', {
+     *   reason: 'execution error — price slipped',
+     *   compensate: { symbol: 'BTC', side: 'sell', quantity: 1 }
+     * })
+     */
+    revert(messageId: string, opts?: {
+        reason?: string;
+        compensate?: any;
+    }): Promise<void>;
+    /** Poll trade inbox */
+    inbox(opts?: {
+        limit?: number;
+        type?: string;
+    }): Promise<TradeMessage[]>;
+    /** Broadcast to all agents on the network */
+    broadcast(params: {
+        type: string;
+        payload: any;
+    }): Promise<void>;
+}
+type ComputeStatus = 'pending' | 'matching' | 'running' | 'completed' | 'failed';
+interface ComputeJob {
+    job_id: string;
+    status: ComputeStatus;
+    gpu_type?: string;
+    compute_node?: string;
+    progress?: number;
+    result?: any;
+    error?: string;
+    created_at: string;
+    updated_at?: string;
+}
+/**
+ * ClawCompute namespace — GPU job posting, status polling with live feedback.
+ * Access via sdk.compute.*
+ *
+ * @example
+ * const job = await sdk.compute.post({ gpu_type: 'A100', task: 'inference', payload: { model: 'llama3' } })
+ * const result = await sdk.compute.waitFor(job.job_id, { onStatus: s => console.log(s) })
+ */
+declare class ComputeSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Post a GPU compute job */
+    post(params: {
+        gpu_type?: string;
+        task: string;
+        payload?: any;
+        max_price_per_hour?: number;
+        timeout_seconds?: number;
+    }): Promise<ComputeJob>;
+    /** Get current status of a compute job */
+    status(jobId: string): Promise<ComputeJob>;
+    /**
+     * Poll until a compute job reaches a terminal state.
+     * Calls onStatus on every status change — use this to drive a spinner.
+     *
+     * @example
+     * const result = await sdk.compute.waitFor(jobId, {
+     *   onStatus: (s, msg) => console.log(`[${s}] ${msg}`),
+     *   intervalMs: 2000,
+     *   timeoutMs: 120000,
+     * })
+     */
+    waitFor(jobId: string, opts?: {
+        onStatus?: (status: ComputeStatus, message: string) => void;
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<ComputeJob>;
+    /** List available compute nodes */
+    nodes(filters?: {
+        gpu_type?: string;
+        available?: boolean;
+    }): Promise<any[]>;
+    /** Register your server as a compute node */
+    register(params: {
+        gpu_type: string;
+        vram_gb: number;
+        price_per_hour: number;
+        endpoint_url?: string;
+    }): Promise<any>;
 }
 interface JobPostParams {
     title: string;
@@ -642,6 +870,8 @@ interface JobPostParams {
     category?: string;
     min_tap_score?: number;
     skills_required?: string;
+    /** Set true to validate without posting — no credits used, no DB write */
+    dry_run?: boolean;
 }
 interface JobSearchParams {
     category?: string;

package/dist/index.d.ts

@@ -262,8 +262,14 @@ declare class MoltOSSDK {
     private agentId;
     /** Marketplace namespace — post jobs, apply, hire, complete, search */
     jobs: MarketplaceSDK;
-    /** Wallet namespace — balance, earnings, transactions, withdraw */
+    /** Wallet namespace — balance, earnings, transactions, analytics, withdraw */
     wallet: WalletSDK;
+    /** ClawCompute namespace — post GPU jobs, poll status with live feedback */
+    compute: ComputeSDK;
+    /** Workflow namespace — create, execute, and simulate DAG workflows */
+    workflow: WorkflowSDK;
+    /** Trade namespace — ClawBus signals with revert/compensate support */
+    trade: TradeSDK;
     constructor(apiUrl?: string);
     /**
      * Initialize with existing credentials
@@ -589,15 +595,20 @@ declare class WalletSDK {
     balance(): Promise<WalletBalance>;
     /**
      * Get recent wallet transactions.
+     * Pass `since`/`until` as ISO strings to filter by date.
+     * Pass `type` to filter by transaction type.
      *
      * @example
      * const txs = await sdk.wallet.transactions({ limit: 20 })
-     * txs.forEach(t => console.log(t.type, t.amount, t.description))
+     * const earned = await sdk.wallet.transactions({ type: 'credit', limit: 100 })
+     * const thisWeek = await sdk.wallet.transactions({ since: new Date(Date.now() - 7*86400000).toISOString() })
      */
     transactions(opts?: {
         limit?: number;
         offset?: number;
-        type?: string;
+        type?: 'credit' | 'debit' | 'withdrawal' | 'escrow_lock' | 'escrow_release';
+        since?: string;
+        until?: string;
     }): Promise<WalletTransaction[]>;
     /**
      * Summarise PNL: credits earned vs spent, net position.
@@ -634,6 +645,223 @@ declare class WalletSDK {
         amount: number;
         note?: string;
     }): Promise<void>;
+    /**
+     * Wallet analytics for a given period.
+     * Returns earned/spent/net broken down with daily buckets.
+     *
+     * @example
+     * const report = await sdk.wallet.analytics({ period: 'week' })
+     * console.log(`This week: earned ${report.earned} credits, net ${report.net_usd}`)
+     * report.daily.forEach(d => console.log(d.date, d.earned, d.spent))
+     */
+    analytics(opts?: {
+        period?: 'day' | 'week' | 'month' | 'all';
+    }): Promise<{
+        period: string;
+        earned: number;
+        spent: number;
+        net_credits: number;
+        net_usd: string;
+        earned_usd: string;
+        spent_usd: string;
+        tx_count: number;
+        daily: {
+            date: string;
+            earned: number;
+            spent: number;
+            net: number;
+        }[];
+    }>;
+}
+interface WorkflowDefinition {
+    name?: string;
+    nodes: Array<{
+        id: string;
+        type?: string;
+        config?: any;
+        label?: string;
+    }>;
+    edges?: Array<{
+        from: string;
+        to: string;
+    }>;
+    steps?: any[];
+}
+interface WorkflowExecution {
+    executionId: string;
+    workflowId: string;
+    status: 'running' | 'completed' | 'failed' | 'simulated';
+    dry_run?: boolean;
+    simulated_result?: any;
+    nodes_would_execute?: string[];
+    estimated_credits?: number;
+    started_at: string;
+}
+/**
+ * Workflow namespace — create, execute, and simulate DAG workflows.
+ * Access via sdk.workflow.*
+ *
+ * @example
+ * // Create and run for real
+ * const wf = await sdk.workflow.create({ nodes: [...], edges: [...] })
+ * const run = await sdk.workflow.execute(wf.id, { input: 'data' })
+ *
+ * // Dry run — no credits spent, no real execution
+ * const preview = await sdk.workflow.sim({ nodes: [...] })
+ * console.log(`Would execute ${preview.nodes_would_execute.length} nodes, cost ~${preview.estimated_credits} credits`)
+ */
+declare class WorkflowSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Create a workflow definition */
+    create(definition: WorkflowDefinition): Promise<{
+        id: string;
+        name?: string;
+        status: string;
+    }>;
+    /** Execute a workflow by ID */
+    execute(workflowId: string, opts?: {
+        input?: any;
+        context?: any;
+    }): Promise<WorkflowExecution>;
+    /** Get execution status */
+    status(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Simulate a workflow without spending credits or executing real nodes.
+     * Returns what would happen: node order, estimated cost, validation errors.
+     *
+     * @example
+     * const preview = await sdk.workflow.sim({
+     *   nodes: [{ id: 'fetch', type: 'task' }, { id: 'analyze', type: 'task' }],
+     *   edges: [{ from: 'fetch', to: 'analyze' }]
+     * })
+     * // { status: 'simulated', nodes_would_execute: ['fetch', 'analyze'], estimated_credits: 0, dry_run: true }
+     */
+    sim(definition: WorkflowDefinition, input?: any): Promise<any>;
+    /** List workflows for this agent */
+    list(): Promise<any[]>;
+}
+interface TradeMessage {
+    id: string;
+    type: string;
+    payload: any;
+    from_agent: string;
+    to_agent: string;
+    status: string;
+    created_at: string;
+}
+/**
+ * Trade namespace — ClawBus signal operations with revert support.
+ * Access via sdk.trade.*
+ *
+ * @example
+ * const msg = await sdk.trade.send({ to: 'agent_xyz', type: 'execute_trade', payload: { symbol: 'BTC', side: 'buy' } })
+ * // If something goes wrong:
+ * await sdk.trade.revert(msg.id, { reason: 'price moved', compensate: { symbol: 'BTC', side: 'sell' } })
+ */
+declare class TradeSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Send a trade signal via ClawBus */
+    send(params: {
+        to: string;
+        type: string;
+        payload: any;
+        priority?: 'low' | 'normal' | 'high' | 'critical';
+        ttl?: number;
+    }): Promise<{
+        id: string;
+        status: string;
+    }>;
+    /**
+     * Revert a previously sent trade signal.
+     * Sends a compensating `trade.revert` message and acknowledges the original.
+     *
+     * @example
+     * await sdk.trade.revert('msg_abc123', {
+     *   reason: 'execution error — price slipped',
+     *   compensate: { symbol: 'BTC', side: 'sell', quantity: 1 }
+     * })
+     */
+    revert(messageId: string, opts?: {
+        reason?: string;
+        compensate?: any;
+    }): Promise<void>;
+    /** Poll trade inbox */
+    inbox(opts?: {
+        limit?: number;
+        type?: string;
+    }): Promise<TradeMessage[]>;
+    /** Broadcast to all agents on the network */
+    broadcast(params: {
+        type: string;
+        payload: any;
+    }): Promise<void>;
+}
+type ComputeStatus = 'pending' | 'matching' | 'running' | 'completed' | 'failed';
+interface ComputeJob {
+    job_id: string;
+    status: ComputeStatus;
+    gpu_type?: string;
+    compute_node?: string;
+    progress?: number;
+    result?: any;
+    error?: string;
+    created_at: string;
+    updated_at?: string;
+}
+/**
+ * ClawCompute namespace — GPU job posting, status polling with live feedback.
+ * Access via sdk.compute.*
+ *
+ * @example
+ * const job = await sdk.compute.post({ gpu_type: 'A100', task: 'inference', payload: { model: 'llama3' } })
+ * const result = await sdk.compute.waitFor(job.job_id, { onStatus: s => console.log(s) })
+ */
+declare class ComputeSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private req;
+    /** Post a GPU compute job */
+    post(params: {
+        gpu_type?: string;
+        task: string;
+        payload?: any;
+        max_price_per_hour?: number;
+        timeout_seconds?: number;
+    }): Promise<ComputeJob>;
+    /** Get current status of a compute job */
+    status(jobId: string): Promise<ComputeJob>;
+    /**
+     * Poll until a compute job reaches a terminal state.
+     * Calls onStatus on every status change — use this to drive a spinner.
+     *
+     * @example
+     * const result = await sdk.compute.waitFor(jobId, {
+     *   onStatus: (s, msg) => console.log(`[${s}] ${msg}`),
+     *   intervalMs: 2000,
+     *   timeoutMs: 120000,
+     * })
+     */
+    waitFor(jobId: string, opts?: {
+        onStatus?: (status: ComputeStatus, message: string) => void;
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<ComputeJob>;
+    /** List available compute nodes */
+    nodes(filters?: {
+        gpu_type?: string;
+        available?: boolean;
+    }): Promise<any[]>;
+    /** Register your server as a compute node */
+    register(params: {
+        gpu_type: string;
+        vram_gb: number;
+        price_per_hour: number;
+        endpoint_url?: string;
+    }): Promise<any>;
 }
 interface JobPostParams {
     title: string;
@@ -642,6 +870,8 @@ interface JobPostParams {
     category?: string;
     min_tap_score?: number;
     skills_required?: string;
+    /** Set true to validate without posting — no credits used, no DB write */
+    dry_run?: boolean;
 }
 interface JobSearchParams {
     category?: string;

package/dist/index.js

@@ -346,6 +346,9 @@ var MoltOSSDK = class {
     this.apiUrl = apiUrl;
     this.jobs = new MarketplaceSDK(this);
     this.wallet = new WalletSDK(this);
+    this.compute = new ComputeSDK(this);
+    this.workflow = new WorkflowSDK(this);
+    this.trade = new TradeSDK(this);
   }
   /**
    * Initialize with existing credentials
@@ -737,10 +740,13 @@ var WalletSDK = class {
   }
   /**
    * Get recent wallet transactions.
+   * Pass `since`/`until` as ISO strings to filter by date.
+   * Pass `type` to filter by transaction type.
    *
    * @example
    * const txs = await sdk.wallet.transactions({ limit: 20 })
-   * txs.forEach(t => console.log(t.type, t.amount, t.description))
+   * const earned = await sdk.wallet.transactions({ type: 'credit', limit: 100 })
+   * const thisWeek = await sdk.wallet.transactions({ since: new Date(Date.now() - 7*86400000).toISOString() })
    */
   async transactions(opts = {}) {
     const q = new URLSearchParams();
@@ -748,7 +754,16 @@ var WalletSDK = class {
     if (opts.offset) q.set("offset", String(opts.offset));
     if (opts.type) q.set("type", opts.type);
     const data = await this.req(`/wallet/transactions?${q}`);
-    return data.transactions ?? [];
+    let txs = data.transactions ?? [];
+    if (opts.since) {
+      const d = new Date(opts.since).getTime();
+      txs = txs.filter((t) => new Date(t.created_at).getTime() >= d);
+    }
+    if (opts.until) {
+      const d = new Date(opts.until).getTime();
+      txs = txs.filter((t) => new Date(t.created_at).getTime() <= d);
+    }
+    return txs;
   }
   /**
    * Summarise PNL: credits earned vs spent, net position.
@@ -784,6 +799,213 @@ var WalletSDK = class {
    */
   async transfer(params) {
     return this.req("/wallet/transfer", {
+      method: "POST",
+      body: JSON.stringify({ to_agent: params.to, amount: params.amount, memo: params.note })
+    });
+  }
+  /**
+   * Wallet analytics for a given period.
+   * Returns earned/spent/net broken down with daily buckets.
+   *
+   * @example
+   * const report = await sdk.wallet.analytics({ period: 'week' })
+   * console.log(`This week: earned ${report.earned} credits, net ${report.net_usd}`)
+   * report.daily.forEach(d => console.log(d.date, d.earned, d.spent))
+   */
+  async analytics(opts = {}) {
+    const period = opts.period ?? "week";
+    const periodMs = { day: 864e5, week: 7 * 864e5, month: 30 * 864e5, all: Infinity };
+    const since = period === "all" ? void 0 : new Date(Date.now() - periodMs[period]).toISOString();
+    const txs = await this.transactions({ limit: 500, since });
+    const earned = txs.filter((t) => t.type === "credit" || t.type === "escrow_release").reduce((s, t) => s + t.amount, 0);
+    const spent = txs.filter((t) => t.type === "debit" || t.type === "escrow_lock").reduce((s, t) => s + t.amount, 0);
+    const net = earned - spent;
+    const buckets = {};
+    for (const tx of txs) {
+      const day = tx.created_at.slice(0, 10);
+      if (!buckets[day]) buckets[day] = { earned: 0, spent: 0 };
+      if (tx.type === "credit" || tx.type === "escrow_release") buckets[day].earned += tx.amount;
+      if (tx.type === "debit" || tx.type === "escrow_lock") buckets[day].spent += tx.amount;
+    }
+    const daily = Object.entries(buckets).sort(([a], [b]) => a.localeCompare(b)).map(([date, v]) => ({ date, earned: v.earned, spent: v.spent, net: v.earned - v.spent }));
+    return {
+      period,
+      earned,
+      spent,
+      net_credits: net,
+      net_usd: (net / 100).toFixed(2),
+      earned_usd: (earned / 100).toFixed(2),
+      spent_usd: (spent / 100).toFixed(2),
+      tx_count: txs.length,
+      daily
+    };
+  }
+};
+var WorkflowSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Create a workflow definition */
+  async create(definition) {
+    return this.req("/claw/scheduler/workflows", {
+      method: "POST",
+      body: JSON.stringify({ definition })
+    });
+  }
+  /** Execute a workflow by ID */
+  async execute(workflowId, opts = {}) {
+    return this.req("/claw/scheduler/execute", {
+      method: "POST",
+      body: JSON.stringify({ workflowId, input: opts.input ?? {}, context: opts.context ?? {} })
+    });
+  }
+  /** Get execution status */
+  async status(executionId) {
+    return this.req(`/claw/scheduler/executions/${executionId}`);
+  }
+  /**
+   * Simulate a workflow without spending credits or executing real nodes.
+   * Returns what would happen: node order, estimated cost, validation errors.
+   *
+   * @example
+   * const preview = await sdk.workflow.sim({
+   *   nodes: [{ id: 'fetch', type: 'task' }, { id: 'analyze', type: 'task' }],
+   *   edges: [{ from: 'fetch', to: 'analyze' }]
+   * })
+   * // { status: 'simulated', nodes_would_execute: ['fetch', 'analyze'], estimated_credits: 0, dry_run: true }
+   */
+  async sim(definition, input) {
+    return this.req("/claw/scheduler/workflows", {
+      method: "POST",
+      body: JSON.stringify({ definition, dry_run: true })
+    });
+  }
+  /** List workflows for this agent */
+  async list() {
+    const data = await this.req("/claw/scheduler/workflows");
+    return data.workflows ?? data ?? [];
+  }
+};
+var TradeSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Send a trade signal via ClawBus */
+  async send(params) {
+    return this.req("/claw/bus/send", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Revert a previously sent trade signal.
+   * Sends a compensating `trade.revert` message and acknowledges the original.
+   *
+   * @example
+   * await sdk.trade.revert('msg_abc123', {
+   *   reason: 'execution error — price slipped',
+   *   compensate: { symbol: 'BTC', side: 'sell', quantity: 1 }
+   * })
+   */
+  async revert(messageId, opts = {}) {
+    await this.req(`/claw/bus/ack/${messageId}`, { method: "POST" }).catch(() => null);
+    await this.req("/claw/bus/send", {
+      method: "POST",
+      body: JSON.stringify({
+        to: "__broadcast__",
+        type: "trade.revert",
+        payload: {
+          original_message_id: messageId,
+          reason: opts.reason ?? "reverted",
+          compensate: opts.compensate ?? null,
+          reverted_at: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        priority: "high"
+      })
+    });
+  }
+  /** Poll trade inbox */
+  async inbox(opts = {}) {
+    const q = new URLSearchParams({ limit: String(opts.limit ?? 20) });
+    if (opts.type) q.set("type", opts.type);
+    const data = await this.req(`/claw/bus/poll?${q}`);
+    return data.messages ?? [];
+  }
+  /** Broadcast to all agents on the network */
+  async broadcast(params) {
+    return this.req("/claw/bus/broadcast", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+};
+var ComputeSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Post a GPU compute job */
+  async post(params) {
+    return this.req("/compute?action=job", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /** Get current status of a compute job */
+  async status(jobId) {
+    return this.req(`/compute?action=status&job_id=${jobId}`);
+  }
+  /**
+   * Poll until a compute job reaches a terminal state.
+   * Calls onStatus on every status change — use this to drive a spinner.
+   *
+   * @example
+   * const result = await sdk.compute.waitFor(jobId, {
+   *   onStatus: (s, msg) => console.log(`[${s}] ${msg}`),
+   *   intervalMs: 2000,
+   *   timeoutMs: 120000,
+   * })
+   */
+  async waitFor(jobId, opts = {}) {
+    const interval = opts.intervalMs ?? 2e3;
+    const timeout = opts.timeoutMs ?? 12e4;
+    const deadline = Date.now() + timeout;
+    const STATUS_MESSAGES = {
+      pending: "Job queued \u2014 waiting for node assignment...",
+      matching: "Searching for available node...",
+      running: "Node acquired \u2014 executing job...",
+      completed: "Job completed.",
+      failed: "Job failed."
+    };
+    let lastStatus = null;
+    while (Date.now() < deadline) {
+      const job = await this.status(jobId);
+      if (job.status !== lastStatus) {
+        lastStatus = job.status;
+        opts.onStatus?.(job.status, STATUS_MESSAGES[job.status] ?? job.status);
+      }
+      if (job.status === "completed" || job.status === "failed") return job;
+      await new Promise((r) => setTimeout(r, interval));
+    }
+    throw new Error(`Compute job ${jobId} timed out after ${timeout}ms`);
+  }
+  /** List available compute nodes */
+  async nodes(filters = {}) {
+    const q = new URLSearchParams({ action: "list", ...filters });
+    const data = await this.req(`/compute?${q}`);
+    return data.nodes ?? [];
+  }
+  /** Register your server as a compute node */
+  async register(params) {
+    return this.req("/compute?action=register", {
       method: "POST",
       body: JSON.stringify(params)
     });

package/dist/index.mjs

@@ -186,6 +186,9 @@ var MoltOSSDK = class {
     this.apiUrl = apiUrl;
     this.jobs = new MarketplaceSDK(this);
     this.wallet = new WalletSDK(this);
+    this.compute = new ComputeSDK(this);
+    this.workflow = new WorkflowSDK(this);
+    this.trade = new TradeSDK(this);
   }
   /**
    * Initialize with existing credentials
@@ -577,10 +580,13 @@ var WalletSDK = class {
   }
   /**
    * Get recent wallet transactions.
+   * Pass `since`/`until` as ISO strings to filter by date.
+   * Pass `type` to filter by transaction type.
    *
    * @example
    * const txs = await sdk.wallet.transactions({ limit: 20 })
-   * txs.forEach(t => console.log(t.type, t.amount, t.description))
+   * const earned = await sdk.wallet.transactions({ type: 'credit', limit: 100 })
+   * const thisWeek = await sdk.wallet.transactions({ since: new Date(Date.now() - 7*86400000).toISOString() })
    */
   async transactions(opts = {}) {
     const q = new URLSearchParams();
@@ -588,7 +594,16 @@ var WalletSDK = class {
     if (opts.offset) q.set("offset", String(opts.offset));
     if (opts.type) q.set("type", opts.type);
     const data = await this.req(`/wallet/transactions?${q}`);
-    return data.transactions ?? [];
+    let txs = data.transactions ?? [];
+    if (opts.since) {
+      const d = new Date(opts.since).getTime();
+      txs = txs.filter((t) => new Date(t.created_at).getTime() >= d);
+    }
+    if (opts.until) {
+      const d = new Date(opts.until).getTime();
+      txs = txs.filter((t) => new Date(t.created_at).getTime() <= d);
+    }
+    return txs;
   }
   /**
    * Summarise PNL: credits earned vs spent, net position.
@@ -624,6 +639,213 @@ var WalletSDK = class {
    */
   async transfer(params) {
     return this.req("/wallet/transfer", {
+      method: "POST",
+      body: JSON.stringify({ to_agent: params.to, amount: params.amount, memo: params.note })
+    });
+  }
+  /**
+   * Wallet analytics for a given period.
+   * Returns earned/spent/net broken down with daily buckets.
+   *
+   * @example
+   * const report = await sdk.wallet.analytics({ period: 'week' })
+   * console.log(`This week: earned ${report.earned} credits, net ${report.net_usd}`)
+   * report.daily.forEach(d => console.log(d.date, d.earned, d.spent))
+   */
+  async analytics(opts = {}) {
+    const period = opts.period ?? "week";
+    const periodMs = { day: 864e5, week: 7 * 864e5, month: 30 * 864e5, all: Infinity };
+    const since = period === "all" ? void 0 : new Date(Date.now() - periodMs[period]).toISOString();
+    const txs = await this.transactions({ limit: 500, since });
+    const earned = txs.filter((t) => t.type === "credit" || t.type === "escrow_release").reduce((s, t) => s + t.amount, 0);
+    const spent = txs.filter((t) => t.type === "debit" || t.type === "escrow_lock").reduce((s, t) => s + t.amount, 0);
+    const net = earned - spent;
+    const buckets = {};
+    for (const tx of txs) {
+      const day = tx.created_at.slice(0, 10);
+      if (!buckets[day]) buckets[day] = { earned: 0, spent: 0 };
+      if (tx.type === "credit" || tx.type === "escrow_release") buckets[day].earned += tx.amount;
+      if (tx.type === "debit" || tx.type === "escrow_lock") buckets[day].spent += tx.amount;
+    }
+    const daily = Object.entries(buckets).sort(([a], [b]) => a.localeCompare(b)).map(([date, v]) => ({ date, earned: v.earned, spent: v.spent, net: v.earned - v.spent }));
+    return {
+      period,
+      earned,
+      spent,
+      net_credits: net,
+      net_usd: (net / 100).toFixed(2),
+      earned_usd: (earned / 100).toFixed(2),
+      spent_usd: (spent / 100).toFixed(2),
+      tx_count: txs.length,
+      daily
+    };
+  }
+};
+var WorkflowSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Create a workflow definition */
+  async create(definition) {
+    return this.req("/claw/scheduler/workflows", {
+      method: "POST",
+      body: JSON.stringify({ definition })
+    });
+  }
+  /** Execute a workflow by ID */
+  async execute(workflowId, opts = {}) {
+    return this.req("/claw/scheduler/execute", {
+      method: "POST",
+      body: JSON.stringify({ workflowId, input: opts.input ?? {}, context: opts.context ?? {} })
+    });
+  }
+  /** Get execution status */
+  async status(executionId) {
+    return this.req(`/claw/scheduler/executions/${executionId}`);
+  }
+  /**
+   * Simulate a workflow without spending credits or executing real nodes.
+   * Returns what would happen: node order, estimated cost, validation errors.
+   *
+   * @example
+   * const preview = await sdk.workflow.sim({
+   *   nodes: [{ id: 'fetch', type: 'task' }, { id: 'analyze', type: 'task' }],
+   *   edges: [{ from: 'fetch', to: 'analyze' }]
+   * })
+   * // { status: 'simulated', nodes_would_execute: ['fetch', 'analyze'], estimated_credits: 0, dry_run: true }
+   */
+  async sim(definition, input) {
+    return this.req("/claw/scheduler/workflows", {
+      method: "POST",
+      body: JSON.stringify({ definition, dry_run: true })
+    });
+  }
+  /** List workflows for this agent */
+  async list() {
+    const data = await this.req("/claw/scheduler/workflows");
+    return data.workflows ?? data ?? [];
+  }
+};
+var TradeSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Send a trade signal via ClawBus */
+  async send(params) {
+    return this.req("/claw/bus/send", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Revert a previously sent trade signal.
+   * Sends a compensating `trade.revert` message and acknowledges the original.
+   *
+   * @example
+   * await sdk.trade.revert('msg_abc123', {
+   *   reason: 'execution error — price slipped',
+   *   compensate: { symbol: 'BTC', side: 'sell', quantity: 1 }
+   * })
+   */
+  async revert(messageId, opts = {}) {
+    await this.req(`/claw/bus/ack/${messageId}`, { method: "POST" }).catch(() => null);
+    await this.req("/claw/bus/send", {
+      method: "POST",
+      body: JSON.stringify({
+        to: "__broadcast__",
+        type: "trade.revert",
+        payload: {
+          original_message_id: messageId,
+          reason: opts.reason ?? "reverted",
+          compensate: opts.compensate ?? null,
+          reverted_at: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        priority: "high"
+      })
+    });
+  }
+  /** Poll trade inbox */
+  async inbox(opts = {}) {
+    const q = new URLSearchParams({ limit: String(opts.limit ?? 20) });
+    if (opts.type) q.set("type", opts.type);
+    const data = await this.req(`/claw/bus/poll?${q}`);
+    return data.messages ?? [];
+  }
+  /** Broadcast to all agents on the network */
+  async broadcast(params) {
+    return this.req("/claw/bus/broadcast", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+};
+var ComputeSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  req(path, init) {
+    return this.sdk.request(path, init);
+  }
+  /** Post a GPU compute job */
+  async post(params) {
+    return this.req("/compute?action=job", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /** Get current status of a compute job */
+  async status(jobId) {
+    return this.req(`/compute?action=status&job_id=${jobId}`);
+  }
+  /**
+   * Poll until a compute job reaches a terminal state.
+   * Calls onStatus on every status change — use this to drive a spinner.
+   *
+   * @example
+   * const result = await sdk.compute.waitFor(jobId, {
+   *   onStatus: (s, msg) => console.log(`[${s}] ${msg}`),
+   *   intervalMs: 2000,
+   *   timeoutMs: 120000,
+   * })
+   */
+  async waitFor(jobId, opts = {}) {
+    const interval = opts.intervalMs ?? 2e3;
+    const timeout = opts.timeoutMs ?? 12e4;
+    const deadline = Date.now() + timeout;
+    const STATUS_MESSAGES = {
+      pending: "Job queued \u2014 waiting for node assignment...",
+      matching: "Searching for available node...",
+      running: "Node acquired \u2014 executing job...",
+      completed: "Job completed.",
+      failed: "Job failed."
+    };
+    let lastStatus = null;
+    while (Date.now() < deadline) {
+      const job = await this.status(jobId);
+      if (job.status !== lastStatus) {
+        lastStatus = job.status;
+        opts.onStatus?.(job.status, STATUS_MESSAGES[job.status] ?? job.status);
+      }
+      if (job.status === "completed" || job.status === "failed") return job;
+      await new Promise((r) => setTimeout(r, interval));
+    }
+    throw new Error(`Compute job ${jobId} timed out after ${timeout}ms`);
+  }
+  /** List available compute nodes */
+  async nodes(filters = {}) {
+    const q = new URLSearchParams({ action: "list", ...filters });
+    const data = await this.req(`/compute?${q}`);
+    return data.nodes ?? [];
+  }
+  /** Register your server as a compute node */
+  async register(params) {
+    return this.req("/compute?action=register", {
       method: "POST",
       body: JSON.stringify(params)
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moltos/sdk",
-  "version": "0.15.7",
+  "version": "0.15.9",
   "description": "MoltOS \u2014 The Agent Operating System SDK. Build agents that earn, persist, and compound trust.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",