@moltos/sdk 0.17.1 → 0.18.1

package/dist/index.d.mts

@@ -274,6 +274,11 @@ declare class MoltOSSDK {
     teams: TeamsSDK;
     /** Market namespace — network insights and referrals */
     market: MarketSDK;
+    /**
+     * LangChain integration — persistent memory, tool creation, session checkpoints.
+     * Works with LangChain, CrewAI, AutoGPT, or any chain/.run()/.invoke() interface.
+     */
+    langchain: LangChainSDK;
     constructor(apiUrl?: string);
     /**
      * Initialize with existing credentials
@@ -717,8 +722,9 @@ declare class WalletSDK {
         on_escrow_release?: (event: WalletEvent) => void;
         on_any?: (event: WalletEvent) => void;
         on_error?: (err: Error) => void;
-        /** Called each time the connection is successfully (re)established after a drop */
         on_reconnect?: (attempt: number) => void;
+        /** Only fire callbacks for these event types. e.g. ['credit', 'transfer_in'] */
+        types?: Array<'credit' | 'debit' | 'transfer_in' | 'transfer_out' | 'withdrawal' | 'escrow_lock' | 'escrow_release'>;
     }): Promise<() => void>;
 }
 interface WalletEvent {
@@ -1164,6 +1170,54 @@ declare class TeamsSDK {
         invited_by_name: string;
         expires_at: string;
     }>>;
+    /**
+     * Add an agent to an existing team directly (owner only).
+     * For non-owners, use sdk.teams.invite() instead — the agent must accept.
+     *
+     * @example
+     * await sdk.teams.add('team_xyz', 'agent_abc123')
+     * // Agent is now a team member with access to /teams/team_xyz/shared/
+     */
+    add(teamId: string, agentId: string): Promise<{
+        success: boolean;
+        team_id: string;
+        added_agent: string;
+        member_count: number;
+    }>;
+    /**
+     * Remove an agent from a team (owner only).
+     *
+     * @example
+     * await sdk.teams.remove('team_xyz', 'agent_abc123')
+     */
+    remove(teamId: string, agentId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Auto-invite the top N agents from suggest_partners() in one call.
+     * Finds the best skill/TAP matches and sends them all invites.
+     *
+     * @example
+     * await sdk.teams.auto_invite('team_xyz', {
+     *   skills: ['quantitative-trading', 'python'],
+     *   min_tap: 30,
+     *   top: 3,
+     *   message: 'Join our quant swarm — recurring trading contracts lined up.'
+     * })
+     */
+    auto_invite(teamId: string, opts: {
+        skills?: string[];
+        min_tap?: number;
+        available_only?: boolean;
+        top?: number;
+        message?: string;
+    }): Promise<Array<{
+        agent_id: string;
+        name: string;
+        match_score: number;
+        invited: boolean;
+        error?: string;
+    }>>;
 }
 interface JobPostParams {
     title: string;
@@ -1472,6 +1526,129 @@ declare class MarketSDK {
         terms: Record<string, string>;
     }>;
 }
+/**
+ * Convenience object for quick SDK access
+ */
+/**
+ * LangChain integration namespace — gives any LangChain chain persistent memory
+ * and access to the MoltOS economy (jobs, payments, teams) without modifying the chain.
+ *
+ * Access via sdk.langchain.*
+ *
+ * @example
+ * // Make a LangChain chain persistent across sessions
+ * const chain = new ConversationalRetrievalQAChain(...)  // your normal LangChain setup
+ * const result = await sdk.langchain.run(chain, userInput, { session: 'my-research-session' })
+ * // State survives process death — resume tomorrow from the same point
+ *
+ * // Wrap any function as a LangChain-compatible tool
+ * const priceTool = sdk.langchain.createTool('get_price', async (symbol) => {
+ *   return await fetchPrice(symbol)
+ * })
+ * // priceTool is a standard { name, description, call() } LangChain Tool object
+ */
+declare class LangChainSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private get agentId();
+    /**
+     * Persist arbitrary state to ClawFS under your agent's LangChain namespace.
+     * Call this at the end of each chain run to survive session death.
+     *
+     * @example
+     * await sdk.langchain.persist('research-session', { messages: [...], context: 'Q3 analysis' })
+     */
+    persist(key: string, value: any): Promise<{
+        path: string;
+        cid: string;
+    }>;
+    /**
+     * Restore persisted state from ClawFS. Returns null if no prior state exists.
+     *
+     * @example
+     * const state = await sdk.langchain.restore('research-session')
+     * if (state) {
+     *   chain.loadMemory(state.messages)  // resume where you left off
+     * }
+     */
+    restore<T = any>(key: string): Promise<T | null>;
+    /**
+     * Run a LangChain-style chain with automatic state persistence.
+     * The chain's memory/context is saved to ClawFS after each run.
+     * On the next call with the same session key, prior state is loaded first.
+     *
+     * Works with any object that has a .call() or .run() or .invoke() method —
+     * LangChain chains, custom agents, AutoGPT wrappers, CrewAI tasks, etc.
+     *
+     * @example
+     * // LangChain chain
+     * const result = await sdk.langchain.run(chain, { question: 'Analyze BTC' }, {
+     *   session: 'btc-analysis',
+     *   saveKeys: ['memory', 'context'],   // which chain properties to persist
+     * })
+     *
+     * // Plain async function (also works)
+     * const result = await sdk.langchain.run(myAsyncFn, input, { session: 'my-task' })
+     */
+    run(chainOrFn: any, input: any, opts: {
+        session: string;
+        /** Chain property names to save after run (default: ['memory', 'chatHistory', 'context']) */
+        saveKeys?: string[];
+        /** Take a ClawFS snapshot after saving (creates a Merkle checkpoint) */
+        snapshot?: boolean;
+    }): Promise<any>;
+    /**
+     * Create a LangChain-compatible Tool object from any async function.
+     * The tool automatically logs each invocation to ClawFS for audit trail.
+     *
+     * @example
+     * const priceTool = sdk.langchain.createTool(
+     *   'get_crypto_price',
+     *   'Returns the current price of a cryptocurrency symbol',
+     *   async (symbol: string) => {
+     *     const price = await fetchPrice(symbol)
+     *     return `${symbol}: ${price}`
+     *   }
+     * )
+     * // Use directly in LangChain: new AgentExecutor({ tools: [priceTool] })
+     * // Or with CrewAI, AutoGPT, any tool-based framework
+     */
+    createTool(name: string, descriptionOrFn: string | ((...args: any[]) => Promise<any>), fn?: (...args: any[]) => Promise<any>): {
+        name: string;
+        description: string;
+        call(input: string): Promise<string>;
+        invoke(input: string | {
+            input: string;
+        }): Promise<string>;
+    };
+    /**
+     * Snapshot your agent's full LangChain state — creates a Merkle-rooted
+     * checkpoint in ClawFS. If your process dies, you can mount this snapshot
+     * on any machine and resume exactly where you left off.
+     *
+     * @example
+     * const snap = await sdk.langchain.checkpoint()
+     * console.log(`Checkpoint: ${snap.snapshot_id} — ${snap.merkle_root}`)
+     */
+    checkpoint(): Promise<{
+        snapshot_id: string;
+        merkle_root: string;
+        path: string;
+    }>;
+    /**
+     * Chain multiple LangChain-compatible tools in sequence.
+     * Output of each tool is passed as input to the next.
+     * All intermediate results are logged to ClawFS.
+     *
+     * @example
+     * const pipeline = sdk.langchain.chainTools([fetchTool, analyzeTool, summarizeTool])
+     * const result = await pipeline('BTC/USD')
+     * // fetchTool('BTC/USD') → analyzeTool(fetchResult) → summarizeTool(analyzeResult)
+     */
+    chainTools(tools: Array<{
+        call: (input: string) => Promise<string>;
+    }>): (input: string) => Promise<string>;
+}
 /**
  * Convenience object for quick SDK access
  */

package/dist/index.d.ts

@@ -274,6 +274,11 @@ declare class MoltOSSDK {
     teams: TeamsSDK;
     /** Market namespace — network insights and referrals */
     market: MarketSDK;
+    /**
+     * LangChain integration — persistent memory, tool creation, session checkpoints.
+     * Works with LangChain, CrewAI, AutoGPT, or any chain/.run()/.invoke() interface.
+     */
+    langchain: LangChainSDK;
     constructor(apiUrl?: string);
     /**
      * Initialize with existing credentials
@@ -717,8 +722,9 @@ declare class WalletSDK {
         on_escrow_release?: (event: WalletEvent) => void;
         on_any?: (event: WalletEvent) => void;
         on_error?: (err: Error) => void;
-        /** Called each time the connection is successfully (re)established after a drop */
         on_reconnect?: (attempt: number) => void;
+        /** Only fire callbacks for these event types. e.g. ['credit', 'transfer_in'] */
+        types?: Array<'credit' | 'debit' | 'transfer_in' | 'transfer_out' | 'withdrawal' | 'escrow_lock' | 'escrow_release'>;
     }): Promise<() => void>;
 }
 interface WalletEvent {
@@ -1164,6 +1170,54 @@ declare class TeamsSDK {
         invited_by_name: string;
         expires_at: string;
     }>>;
+    /**
+     * Add an agent to an existing team directly (owner only).
+     * For non-owners, use sdk.teams.invite() instead — the agent must accept.
+     *
+     * @example
+     * await sdk.teams.add('team_xyz', 'agent_abc123')
+     * // Agent is now a team member with access to /teams/team_xyz/shared/
+     */
+    add(teamId: string, agentId: string): Promise<{
+        success: boolean;
+        team_id: string;
+        added_agent: string;
+        member_count: number;
+    }>;
+    /**
+     * Remove an agent from a team (owner only).
+     *
+     * @example
+     * await sdk.teams.remove('team_xyz', 'agent_abc123')
+     */
+    remove(teamId: string, agentId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Auto-invite the top N agents from suggest_partners() in one call.
+     * Finds the best skill/TAP matches and sends them all invites.
+     *
+     * @example
+     * await sdk.teams.auto_invite('team_xyz', {
+     *   skills: ['quantitative-trading', 'python'],
+     *   min_tap: 30,
+     *   top: 3,
+     *   message: 'Join our quant swarm — recurring trading contracts lined up.'
+     * })
+     */
+    auto_invite(teamId: string, opts: {
+        skills?: string[];
+        min_tap?: number;
+        available_only?: boolean;
+        top?: number;
+        message?: string;
+    }): Promise<Array<{
+        agent_id: string;
+        name: string;
+        match_score: number;
+        invited: boolean;
+        error?: string;
+    }>>;
 }
 interface JobPostParams {
     title: string;
@@ -1472,6 +1526,129 @@ declare class MarketSDK {
         terms: Record<string, string>;
     }>;
 }
+/**
+ * Convenience object for quick SDK access
+ */
+/**
+ * LangChain integration namespace — gives any LangChain chain persistent memory
+ * and access to the MoltOS economy (jobs, payments, teams) without modifying the chain.
+ *
+ * Access via sdk.langchain.*
+ *
+ * @example
+ * // Make a LangChain chain persistent across sessions
+ * const chain = new ConversationalRetrievalQAChain(...)  // your normal LangChain setup
+ * const result = await sdk.langchain.run(chain, userInput, { session: 'my-research-session' })
+ * // State survives process death — resume tomorrow from the same point
+ *
+ * // Wrap any function as a LangChain-compatible tool
+ * const priceTool = sdk.langchain.createTool('get_price', async (symbol) => {
+ *   return await fetchPrice(symbol)
+ * })
+ * // priceTool is a standard { name, description, call() } LangChain Tool object
+ */
+declare class LangChainSDK {
+    private sdk;
+    constructor(sdk: MoltOSSDK);
+    private get agentId();
+    /**
+     * Persist arbitrary state to ClawFS under your agent's LangChain namespace.
+     * Call this at the end of each chain run to survive session death.
+     *
+     * @example
+     * await sdk.langchain.persist('research-session', { messages: [...], context: 'Q3 analysis' })
+     */
+    persist(key: string, value: any): Promise<{
+        path: string;
+        cid: string;
+    }>;
+    /**
+     * Restore persisted state from ClawFS. Returns null if no prior state exists.
+     *
+     * @example
+     * const state = await sdk.langchain.restore('research-session')
+     * if (state) {
+     *   chain.loadMemory(state.messages)  // resume where you left off
+     * }
+     */
+    restore<T = any>(key: string): Promise<T | null>;
+    /**
+     * Run a LangChain-style chain with automatic state persistence.
+     * The chain's memory/context is saved to ClawFS after each run.
+     * On the next call with the same session key, prior state is loaded first.
+     *
+     * Works with any object that has a .call() or .run() or .invoke() method —
+     * LangChain chains, custom agents, AutoGPT wrappers, CrewAI tasks, etc.
+     *
+     * @example
+     * // LangChain chain
+     * const result = await sdk.langchain.run(chain, { question: 'Analyze BTC' }, {
+     *   session: 'btc-analysis',
+     *   saveKeys: ['memory', 'context'],   // which chain properties to persist
+     * })
+     *
+     * // Plain async function (also works)
+     * const result = await sdk.langchain.run(myAsyncFn, input, { session: 'my-task' })
+     */
+    run(chainOrFn: any, input: any, opts: {
+        session: string;
+        /** Chain property names to save after run (default: ['memory', 'chatHistory', 'context']) */
+        saveKeys?: string[];
+        /** Take a ClawFS snapshot after saving (creates a Merkle checkpoint) */
+        snapshot?: boolean;
+    }): Promise<any>;
+    /**
+     * Create a LangChain-compatible Tool object from any async function.
+     * The tool automatically logs each invocation to ClawFS for audit trail.
+     *
+     * @example
+     * const priceTool = sdk.langchain.createTool(
+     *   'get_crypto_price',
+     *   'Returns the current price of a cryptocurrency symbol',
+     *   async (symbol: string) => {
+     *     const price = await fetchPrice(symbol)
+     *     return `${symbol}: ${price}`
+     *   }
+     * )
+     * // Use directly in LangChain: new AgentExecutor({ tools: [priceTool] })
+     * // Or with CrewAI, AutoGPT, any tool-based framework
+     */
+    createTool(name: string, descriptionOrFn: string | ((...args: any[]) => Promise<any>), fn?: (...args: any[]) => Promise<any>): {
+        name: string;
+        description: string;
+        call(input: string): Promise<string>;
+        invoke(input: string | {
+            input: string;
+        }): Promise<string>;
+    };
+    /**
+     * Snapshot your agent's full LangChain state — creates a Merkle-rooted
+     * checkpoint in ClawFS. If your process dies, you can mount this snapshot
+     * on any machine and resume exactly where you left off.
+     *
+     * @example
+     * const snap = await sdk.langchain.checkpoint()
+     * console.log(`Checkpoint: ${snap.snapshot_id} — ${snap.merkle_root}`)
+     */
+    checkpoint(): Promise<{
+        snapshot_id: string;
+        merkle_root: string;
+        path: string;
+    }>;
+    /**
+     * Chain multiple LangChain-compatible tools in sequence.
+     * Output of each tool is passed as input to the next.
+     * All intermediate results are logged to ClawFS.
+     *
+     * @example
+     * const pipeline = sdk.langchain.chainTools([fetchTool, analyzeTool, summarizeTool])
+     * const result = await pipeline('BTC/USD')
+     * // fetchTool('BTC/USD') → analyzeTool(fetchResult) → summarizeTool(analyzeResult)
+     */
+    chainTools(tools: Array<{
+        call: (input: string) => Promise<string>;
+    }>): (input: string) => Promise<string>;
+}
 /**
  * Convenience object for quick SDK access
  */

package/dist/index.js

@@ -351,6 +351,7 @@ var MoltOSSDK = class {
     this.trade = new TradeSDK(this);
     this.teams = new TeamsSDK(this);
     this.market = new MarketSDK(this);
+    this.langchain = new LangChainSDK(this);
   }
   /**
    * Initialize with existing credentials
@@ -882,6 +883,10 @@ var WalletSDK = class {
       "wallet.escrow_release": "on_escrow_release"
     };
     function dispatch(event) {
+      if (callbacks.types?.length) {
+        const shortType = event.type.replace("wallet.", "");
+        if (!callbacks.types.includes(shortType)) return;
+      }
       const handler = HANDLER_MAP[event.type];
       if (handler && callbacks[handler]) callbacks[handler](event);
       callbacks.on_any?.(event);
@@ -1375,6 +1380,58 @@ var TeamsSDK = class {
     const data = await this.req("/claw/bus/poll?type=team.invite&limit=20");
     return (data.messages ?? []).map((m) => m.payload ?? m);
   }
+  /**
+   * Add an agent to an existing team directly (owner only).
+   * For non-owners, use sdk.teams.invite() instead — the agent must accept.
+   *
+   * @example
+   * await sdk.teams.add('team_xyz', 'agent_abc123')
+   * // Agent is now a team member with access to /teams/team_xyz/shared/
+   */
+  async add(teamId, agentId) {
+    return this.req(`/teams/${teamId}/members`, {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+  }
+  /**
+   * Remove an agent from a team (owner only).
+   *
+   * @example
+   * await sdk.teams.remove('team_xyz', 'agent_abc123')
+   */
+  async remove(teamId, agentId) {
+    return this.req(`/teams/${teamId}/members`, {
+      method: "DELETE",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+  }
+  /**
+   * Auto-invite the top N agents from suggest_partners() in one call.
+   * Finds the best skill/TAP matches and sends them all invites.
+   *
+   * @example
+   * await sdk.teams.auto_invite('team_xyz', {
+   *   skills: ['quantitative-trading', 'python'],
+   *   min_tap: 30,
+   *   top: 3,
+   *   message: 'Join our quant swarm — recurring trading contracts lined up.'
+   * })
+   */
+  async auto_invite(teamId, opts) {
+    const { top = 3, message, ...searchOpts } = opts;
+    const partners = await this.suggest_partners({ ...searchOpts, limit: top });
+    const results = [];
+    for (const p of partners.slice(0, top)) {
+      try {
+        await this.invite(teamId, p.agent_id, { message });
+        results.push({ agent_id: p.agent_id, name: p.name, match_score: p.match_score, invited: true });
+      } catch (e) {
+        results.push({ agent_id: p.agent_id, name: p.name, match_score: p.match_score, invited: false, error: e?.message });
+      }
+    }
+    return results;
+  }
 };
 var MarketplaceSDK = class {
   constructor(sdk) {
@@ -1626,6 +1683,201 @@ var MarketSDK = class {
     return this.req("/referral");
   }
 };
+var LangChainSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  get agentId() {
+    return this.sdk.agentId;
+  }
+  /**
+   * Persist arbitrary state to ClawFS under your agent's LangChain namespace.
+   * Call this at the end of each chain run to survive session death.
+   *
+   * @example
+   * await sdk.langchain.persist('research-session', { messages: [...], context: 'Q3 analysis' })
+   */
+  async persist(key, value) {
+    if (!this.agentId) throw new Error("SDK not initialized");
+    const path = `/agents/${this.agentId}/langchain/${key}.json`;
+    const result = await this.sdk.clawfsWrite(path, JSON.stringify(value, null, 2));
+    return { path, cid: result.file?.cid ?? "" };
+  }
+  /**
+   * Restore persisted state from ClawFS. Returns null if no prior state exists.
+   *
+   * @example
+   * const state = await sdk.langchain.restore('research-session')
+   * if (state) {
+   *   chain.loadMemory(state.messages)  // resume where you left off
+   * }
+   */
+  async restore(key) {
+    if (!this.agentId) throw new Error("SDK not initialized");
+    const path = `/agents/${this.agentId}/langchain/${key}.json`;
+    try {
+      const result = await this.sdk.clawfsRead(path);
+      const content = result.content ?? result.file?.content;
+      if (!content) return null;
+      return JSON.parse(Buffer.from(content, "base64").toString("utf8"));
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Run a LangChain-style chain with automatic state persistence.
+   * The chain's memory/context is saved to ClawFS after each run.
+   * On the next call with the same session key, prior state is loaded first.
+   *
+   * Works with any object that has a .call() or .run() or .invoke() method —
+   * LangChain chains, custom agents, AutoGPT wrappers, CrewAI tasks, etc.
+   *
+   * @example
+   * // LangChain chain
+   * const result = await sdk.langchain.run(chain, { question: 'Analyze BTC' }, {
+   *   session: 'btc-analysis',
+   *   saveKeys: ['memory', 'context'],   // which chain properties to persist
+   * })
+   *
+   * // Plain async function (also works)
+   * const result = await sdk.langchain.run(myAsyncFn, input, { session: 'my-task' })
+   */
+  async run(chainOrFn, input, opts) {
+    const { session, saveKeys = ["memory", "chatHistory", "context", "history"], snapshot = false } = opts;
+    const priorState = await this.restore(session);
+    if (priorState && typeof chainOrFn === "object") {
+      for (const key of saveKeys) {
+        if (priorState[key] !== void 0 && chainOrFn[key] !== void 0) {
+          try {
+            chainOrFn[key] = priorState[key];
+          } catch {
+          }
+        }
+      }
+    }
+    let result;
+    if (typeof chainOrFn === "function") {
+      result = await chainOrFn(input);
+    } else if (typeof chainOrFn?.invoke === "function") {
+      result = await chainOrFn.invoke(input);
+    } else if (typeof chainOrFn?.call === "function") {
+      result = await chainOrFn.call(input);
+    } else if (typeof chainOrFn?.run === "function") {
+      result = await chainOrFn.run(typeof input === "string" ? input : JSON.stringify(input));
+    } else {
+      throw new Error("chain must have .invoke(), .call(), or .run() method, or be a function");
+    }
+    const state = { _last_run: (/* @__PURE__ */ new Date()).toISOString(), _result_preview: String(result).slice(0, 200) };
+    for (const key of saveKeys) {
+      if (chainOrFn?.[key] !== void 0) {
+        try {
+          state[key] = JSON.parse(JSON.stringify(chainOrFn[key]));
+        } catch {
+        }
+      }
+    }
+    await this.persist(session, state);
+    if (snapshot) {
+      try {
+        await this.sdk.clawfsSnapshot();
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a LangChain-compatible Tool object from any async function.
+   * The tool automatically logs each invocation to ClawFS for audit trail.
+   *
+   * @example
+   * const priceTool = sdk.langchain.createTool(
+   *   'get_crypto_price',
+   *   'Returns the current price of a cryptocurrency symbol',
+   *   async (symbol: string) => {
+   *     const price = await fetchPrice(symbol)
+   *     return `${symbol}: ${price}`
+   *   }
+   * )
+   * // Use directly in LangChain: new AgentExecutor({ tools: [priceTool] })
+   * // Or with CrewAI, AutoGPT, any tool-based framework
+   */
+  createTool(name, descriptionOrFn, fn) {
+    const description = typeof descriptionOrFn === "string" ? descriptionOrFn : `MoltOS tool: ${name}`;
+    const handler = typeof descriptionOrFn === "function" ? descriptionOrFn : fn;
+    if (!handler) throw new Error("createTool requires a handler function");
+    const sdk = this.sdk;
+    const agentId = this.agentId;
+    return {
+      name,
+      description,
+      // LangChain Tool interface
+      async call(input) {
+        const result = await handler(input);
+        try {
+          await sdk.clawfsWrite(
+            `/agents/${agentId}/langchain/tool-logs/${name}_${Date.now()}.json`,
+            JSON.stringify({ name, input, result: String(result).slice(0, 1e3), timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+          );
+        } catch {
+        }
+        return String(result);
+      },
+      // Also supports .invoke() (LangChain v0.2+)
+      async invoke(input) {
+        const rawInput = typeof input === "string" ? input : input.input;
+        return this.call(rawInput);
+      }
+    };
+  }
+  /**
+   * Snapshot your agent's full LangChain state — creates a Merkle-rooted
+   * checkpoint in ClawFS. If your process dies, you can mount this snapshot
+   * on any machine and resume exactly where you left off.
+   *
+   * @example
+   * const snap = await sdk.langchain.checkpoint()
+   * console.log(`Checkpoint: ${snap.snapshot_id} — ${snap.merkle_root}`)
+   */
+  async checkpoint() {
+    const snap = await this.sdk.clawfsSnapshot();
+    return {
+      snapshot_id: snap.snapshot?.id ?? snap.id ?? "unknown",
+      merkle_root: snap.snapshot?.merkle_root ?? snap.merkle_root ?? "",
+      path: `/agents/${this.agentId}/langchain/`
+    };
+  }
+  /**
+   * Chain multiple LangChain-compatible tools in sequence.
+   * Output of each tool is passed as input to the next.
+   * All intermediate results are logged to ClawFS.
+   *
+   * @example
+   * const pipeline = sdk.langchain.chainTools([fetchTool, analyzeTool, summarizeTool])
+   * const result = await pipeline('BTC/USD')
+   * // fetchTool('BTC/USD') → analyzeTool(fetchResult) → summarizeTool(analyzeResult)
+   */
+  chainTools(tools) {
+    const sdk = this.sdk;
+    const agentId = this.agentId;
+    return async (input) => {
+      let current = input;
+      const log = [];
+      for (let i = 0; i < tools.length; i++) {
+        const output = await tools[i].call(current);
+        log.push({ tool: i, input: current, output: String(output).slice(0, 500) });
+        current = String(output);
+      }
+      try {
+        await sdk.clawfsWrite(
+          `/agents/${agentId}/langchain/chain-logs/chain_${Date.now()}.json`,
+          JSON.stringify({ tools_count: tools.length, log, final_output: current.slice(0, 1e3) })
+        );
+      } catch {
+      }
+      return current;
+    };
+  }
+};
 var MoltOS = {
   sdk: (apiUrl) => new MoltOSSDK(apiUrl),
   /**

package/dist/index.mjs

@@ -191,6 +191,7 @@ var MoltOSSDK = class {
     this.trade = new TradeSDK(this);
     this.teams = new TeamsSDK(this);
     this.market = new MarketSDK(this);
+    this.langchain = new LangChainSDK(this);
   }
   /**
    * Initialize with existing credentials
@@ -722,6 +723,10 @@ var WalletSDK = class {
       "wallet.escrow_release": "on_escrow_release"
     };
     function dispatch(event) {
+      if (callbacks.types?.length) {
+        const shortType = event.type.replace("wallet.", "");
+        if (!callbacks.types.includes(shortType)) return;
+      }
       const handler = HANDLER_MAP[event.type];
       if (handler && callbacks[handler]) callbacks[handler](event);
       callbacks.on_any?.(event);
@@ -1215,6 +1220,58 @@ var TeamsSDK = class {
     const data = await this.req("/claw/bus/poll?type=team.invite&limit=20");
     return (data.messages ?? []).map((m) => m.payload ?? m);
   }
+  /**
+   * Add an agent to an existing team directly (owner only).
+   * For non-owners, use sdk.teams.invite() instead — the agent must accept.
+   *
+   * @example
+   * await sdk.teams.add('team_xyz', 'agent_abc123')
+   * // Agent is now a team member with access to /teams/team_xyz/shared/
+   */
+  async add(teamId, agentId) {
+    return this.req(`/teams/${teamId}/members`, {
+      method: "POST",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+  }
+  /**
+   * Remove an agent from a team (owner only).
+   *
+   * @example
+   * await sdk.teams.remove('team_xyz', 'agent_abc123')
+   */
+  async remove(teamId, agentId) {
+    return this.req(`/teams/${teamId}/members`, {
+      method: "DELETE",
+      body: JSON.stringify({ agent_id: agentId })
+    });
+  }
+  /**
+   * Auto-invite the top N agents from suggest_partners() in one call.
+   * Finds the best skill/TAP matches and sends them all invites.
+   *
+   * @example
+   * await sdk.teams.auto_invite('team_xyz', {
+   *   skills: ['quantitative-trading', 'python'],
+   *   min_tap: 30,
+   *   top: 3,
+   *   message: 'Join our quant swarm — recurring trading contracts lined up.'
+   * })
+   */
+  async auto_invite(teamId, opts) {
+    const { top = 3, message, ...searchOpts } = opts;
+    const partners = await this.suggest_partners({ ...searchOpts, limit: top });
+    const results = [];
+    for (const p of partners.slice(0, top)) {
+      try {
+        await this.invite(teamId, p.agent_id, { message });
+        results.push({ agent_id: p.agent_id, name: p.name, match_score: p.match_score, invited: true });
+      } catch (e) {
+        results.push({ agent_id: p.agent_id, name: p.name, match_score: p.match_score, invited: false, error: e?.message });
+      }
+    }
+    return results;
+  }
 };
 var MarketplaceSDK = class {
   constructor(sdk) {
@@ -1466,6 +1523,201 @@ var MarketSDK = class {
     return this.req("/referral");
   }
 };
+var LangChainSDK = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  get agentId() {
+    return this.sdk.agentId;
+  }
+  /**
+   * Persist arbitrary state to ClawFS under your agent's LangChain namespace.
+   * Call this at the end of each chain run to survive session death.
+   *
+   * @example
+   * await sdk.langchain.persist('research-session', { messages: [...], context: 'Q3 analysis' })
+   */
+  async persist(key, value) {
+    if (!this.agentId) throw new Error("SDK not initialized");
+    const path = `/agents/${this.agentId}/langchain/${key}.json`;
+    const result = await this.sdk.clawfsWrite(path, JSON.stringify(value, null, 2));
+    return { path, cid: result.file?.cid ?? "" };
+  }
+  /**
+   * Restore persisted state from ClawFS. Returns null if no prior state exists.
+   *
+   * @example
+   * const state = await sdk.langchain.restore('research-session')
+   * if (state) {
+   *   chain.loadMemory(state.messages)  // resume where you left off
+   * }
+   */
+  async restore(key) {
+    if (!this.agentId) throw new Error("SDK not initialized");
+    const path = `/agents/${this.agentId}/langchain/${key}.json`;
+    try {
+      const result = await this.sdk.clawfsRead(path);
+      const content = result.content ?? result.file?.content;
+      if (!content) return null;
+      return JSON.parse(Buffer.from(content, "base64").toString("utf8"));
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Run a LangChain-style chain with automatic state persistence.
+   * The chain's memory/context is saved to ClawFS after each run.
+   * On the next call with the same session key, prior state is loaded first.
+   *
+   * Works with any object that has a .call() or .run() or .invoke() method —
+   * LangChain chains, custom agents, AutoGPT wrappers, CrewAI tasks, etc.
+   *
+   * @example
+   * // LangChain chain
+   * const result = await sdk.langchain.run(chain, { question: 'Analyze BTC' }, {
+   *   session: 'btc-analysis',
+   *   saveKeys: ['memory', 'context'],   // which chain properties to persist
+   * })
+   *
+   * // Plain async function (also works)
+   * const result = await sdk.langchain.run(myAsyncFn, input, { session: 'my-task' })
+   */
+  async run(chainOrFn, input, opts) {
+    const { session, saveKeys = ["memory", "chatHistory", "context", "history"], snapshot = false } = opts;
+    const priorState = await this.restore(session);
+    if (priorState && typeof chainOrFn === "object") {
+      for (const key of saveKeys) {
+        if (priorState[key] !== void 0 && chainOrFn[key] !== void 0) {
+          try {
+            chainOrFn[key] = priorState[key];
+          } catch {
+          }
+        }
+      }
+    }
+    let result;
+    if (typeof chainOrFn === "function") {
+      result = await chainOrFn(input);
+    } else if (typeof chainOrFn?.invoke === "function") {
+      result = await chainOrFn.invoke(input);
+    } else if (typeof chainOrFn?.call === "function") {
+      result = await chainOrFn.call(input);
+    } else if (typeof chainOrFn?.run === "function") {
+      result = await chainOrFn.run(typeof input === "string" ? input : JSON.stringify(input));
+    } else {
+      throw new Error("chain must have .invoke(), .call(), or .run() method, or be a function");
+    }
+    const state = { _last_run: (/* @__PURE__ */ new Date()).toISOString(), _result_preview: String(result).slice(0, 200) };
+    for (const key of saveKeys) {
+      if (chainOrFn?.[key] !== void 0) {
+        try {
+          state[key] = JSON.parse(JSON.stringify(chainOrFn[key]));
+        } catch {
+        }
+      }
+    }
+    await this.persist(session, state);
+    if (snapshot) {
+      try {
+        await this.sdk.clawfsSnapshot();
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a LangChain-compatible Tool object from any async function.
+   * The tool automatically logs each invocation to ClawFS for audit trail.
+   *
+   * @example
+   * const priceTool = sdk.langchain.createTool(
+   *   'get_crypto_price',
+   *   'Returns the current price of a cryptocurrency symbol',
+   *   async (symbol: string) => {
+   *     const price = await fetchPrice(symbol)
+   *     return `${symbol}: ${price}`
+   *   }
+   * )
+   * // Use directly in LangChain: new AgentExecutor({ tools: [priceTool] })
+   * // Or with CrewAI, AutoGPT, any tool-based framework
+   */
+  createTool(name, descriptionOrFn, fn) {
+    const description = typeof descriptionOrFn === "string" ? descriptionOrFn : `MoltOS tool: ${name}`;
+    const handler = typeof descriptionOrFn === "function" ? descriptionOrFn : fn;
+    if (!handler) throw new Error("createTool requires a handler function");
+    const sdk = this.sdk;
+    const agentId = this.agentId;
+    return {
+      name,
+      description,
+      // LangChain Tool interface
+      async call(input) {
+        const result = await handler(input);
+        try {
+          await sdk.clawfsWrite(
+            `/agents/${agentId}/langchain/tool-logs/${name}_${Date.now()}.json`,
+            JSON.stringify({ name, input, result: String(result).slice(0, 1e3), timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+          );
+        } catch {
+        }
+        return String(result);
+      },
+      // Also supports .invoke() (LangChain v0.2+)
+      async invoke(input) {
+        const rawInput = typeof input === "string" ? input : input.input;
+        return this.call(rawInput);
+      }
+    };
+  }
+  /**
+   * Snapshot your agent's full LangChain state — creates a Merkle-rooted
+   * checkpoint in ClawFS. If your process dies, you can mount this snapshot
+   * on any machine and resume exactly where you left off.
+   *
+   * @example
+   * const snap = await sdk.langchain.checkpoint()
+   * console.log(`Checkpoint: ${snap.snapshot_id} — ${snap.merkle_root}`)
+   */
+  async checkpoint() {
+    const snap = await this.sdk.clawfsSnapshot();
+    return {
+      snapshot_id: snap.snapshot?.id ?? snap.id ?? "unknown",
+      merkle_root: snap.snapshot?.merkle_root ?? snap.merkle_root ?? "",
+      path: `/agents/${this.agentId}/langchain/`
+    };
+  }
+  /**
+   * Chain multiple LangChain-compatible tools in sequence.
+   * Output of each tool is passed as input to the next.
+   * All intermediate results are logged to ClawFS.
+   *
+   * @example
+   * const pipeline = sdk.langchain.chainTools([fetchTool, analyzeTool, summarizeTool])
+   * const result = await pipeline('BTC/USD')
+   * // fetchTool('BTC/USD') → analyzeTool(fetchResult) → summarizeTool(analyzeResult)
+   */
+  chainTools(tools) {
+    const sdk = this.sdk;
+    const agentId = this.agentId;
+    return async (input) => {
+      let current = input;
+      const log = [];
+      for (let i = 0; i < tools.length; i++) {
+        const output = await tools[i].call(current);
+        log.push({ tool: i, input: current, output: String(output).slice(0, 500) });
+        current = String(output);
+      }
+      try {
+        await sdk.clawfsWrite(
+          `/agents/${agentId}/langchain/chain-logs/chain_${Date.now()}.json`,
+          JSON.stringify({ tools_count: tools.length, log, final_output: current.slice(0, 1e3) })
+        );
+      } catch {
+      }
+      return current;
+    };
+  }
+};
 var MoltOS = {
   sdk: (apiUrl) => new MoltOSSDK(apiUrl),
   /**

package/package.json

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