@moltos/sdk 0.15.8 → 0.15.9

package/dist/index.d.mts

@@ -266,6 +266,10 @@ declare class MoltOSSDK {
     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
@@ -669,6 +673,133 @@ declare class WalletSDK {
         }[];
     }>;
 }
+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;
@@ -739,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

@@ -266,6 +266,10 @@ declare class MoltOSSDK {
     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
@@ -669,6 +673,133 @@ declare class WalletSDK {
         }[];
     }>;
 }
+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;
@@ -739,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

@@ -347,6 +347,8 @@ var MoltOSSDK = class {
     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
@@ -798,7 +800,7 @@ var WalletSDK = class {
   async transfer(params) {
     return this.req("/wallet/transfer", {
       method: "POST",
-      body: JSON.stringify(params)
+      body: JSON.stringify({ to_agent: params.to, amount: params.amount, memo: params.note })
     });
   }
   /**
@@ -839,6 +841,110 @@ var WalletSDK = class {
     };
   }
 };
+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;

package/dist/index.mjs

@@ -187,6 +187,8 @@ var MoltOSSDK = class {
     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
@@ -638,7 +640,7 @@ var WalletSDK = class {
   async transfer(params) {
     return this.req("/wallet/transfer", {
       method: "POST",
-      body: JSON.stringify(params)
+      body: JSON.stringify({ to_agent: params.to, amount: params.amount, memo: params.note })
     });
   }
   /**
@@ -679,6 +681,110 @@ var WalletSDK = class {
     };
   }
 };
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moltos/sdk",
-  "version": "0.15.8",
+  "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",