@openagentmarket/nodejs 1.1.2 → 1.3.0

package/my-hirer/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "my-hirer",
+  "version": "1.0.0",
+  "description": "Hire agents on OpenAgent Market",
+  "type": "module",
+  "scripts": {
+    "start": "tsx index.ts",
+    "dev": "tsx watch index.ts"
+  },
+  "dependencies": {
+    "@openagentmarket/nodejs": "^1.0.0",
+    "ethers": "^6.10.0",
+    "dotenv": "^16.4.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "@types/node": "^20.11.0"
+  }
+}

package/my-hirer/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagentmarket/nodejs",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "OpenAgent Market Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -24,6 +24,7 @@
   "license": "MIT",
   "dependencies": {
     "@xmtp/agent-sdk": "^1.0.0",
+    "@xmtp/node-sdk": "^4.6.0",
     "agent0-sdk": "^1.5.3",
     "dotenv": "^16.4.0",
     "ethers": "^6.10.0"

package/src/client.ts

@@ -0,0 +1,282 @@
+import { Client, ConsentState } from '@xmtp/node-sdk';
+import { type Signer, Wallet, HDNodeWallet, getBytes } from 'ethers';
+
+export interface OpenAgentClientConfig {
+    mnemonic?: string;
+    privateKey?: string;
+    env?: "production" | "dev" | "local";
+}
+
+export interface TaskResult {
+    /** True if the agent returned a result */
+    success: boolean;
+    /** The result data from the agent (JSON-RPC response) */
+    result?: any;
+    /** If the agent demanded payment */
+    paymentRequired?: {
+        amount: number;
+        currency: string;
+        recipient: string;
+        chainId: number;
+    };
+    /** Raw response text */
+    raw?: string;
+    /** Error message if something went wrong */
+    error?: string;
+}
+
+export interface SendTaskOptions {
+    /** Timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Payment proof transaction hash (if prepaying) */
+    txHash?: string;
+}
+
+/**
+ * OpenAgentClient — buyer-side SDK for hiring agents via XMTP.
+ *
+ * No registration or agent card needed. Just create a client and start
+ * sending tasks to agents by their wallet address.
+ *
+ * ```typescript
+ * const client = await OpenAgentClient.create({ mnemonic: process.env.MNEMONIC, env: "production" });
+ * const result = await client.sendTask("0xAgentAddress", "buy_key", { name: "My Key" });
+ * ```
+ */
+export class OpenAgentClient {
+    private client: Client;
+    private wallet: Wallet | HDNodeWallet;
+
+    private constructor(client: Client, wallet: Wallet | HDNodeWallet) {
+        this.client = client;
+        this.wallet = wallet;
+    }
+
+    /**
+     * Create a new OpenAgentClient.
+     * Handles wallet creation and XMTP connection.
+     */
+    public static async create(config: OpenAgentClientConfig): Promise<OpenAgentClient> {
+        let wallet: Wallet | HDNodeWallet;
+
+        if (config.mnemonic) {
+            wallet = Wallet.fromPhrase(config.mnemonic);
+        } else if (config.privateKey) {
+            wallet = new Wallet(config.privateKey);
+        } else {
+            wallet = Wallet.createRandom();
+        }
+
+        // Build XMTP signer adapter
+        const signer = {
+            getAddress: async () => wallet.address,
+            getIdentifier: () => ({
+                identifier: wallet.address,
+                identifierKind: 0
+            }),
+            signMessage: async (message: string | Uint8Array) => {
+                const sig = await wallet.signMessage(message);
+                return getBytes(sig);
+            },
+            type: "EOA"
+        };
+
+        const client = await Client.create(signer as any, {
+            env: config.env || "production"
+        });
+
+        console.log(`[OpenAgentClient] Connected as ${wallet.address}`);
+        return new OpenAgentClient(client, wallet);
+    }
+
+    /**
+     * Get the client's wallet address.
+     */
+    public getAddress(): string {
+        return this.wallet.address;
+    }
+
+    /**
+     * Send a named task to an agent and wait for the response.
+     *
+     * @param agentAddress - The target agent's wallet address
+     * @param method - The task name (e.g. "buy_key", "say_hello")
+     * @param params - Task input parameters
+     * @param opts - Optional: timeout, payment txHash
+     * @returns TaskResult with the response or payment demand
+     */
+    public async sendTask(
+        agentAddress: string,
+        method: string,
+        params: Record<string, any> = {},
+        opts?: SendTaskOptions
+    ): Promise<TaskResult> {
+        const timeout = opts?.timeout ?? 30000;
+
+        // Open DM with the agent
+        const conversation = await this.client.conversations.newDmWithIdentifier({
+            identifier: agentAddress,
+            identifierKind: 0
+        });
+
+        // Build JSON-RPC request
+        const request: Record<string, any> = {
+            method,
+            params,
+            id: Date.now()
+        };
+
+        // Attach payment proof if provided
+        if (opts?.txHash) {
+            request.payment = { txHash: opts.txHash };
+        }
+
+        // Send as string
+        await conversation.send(JSON.stringify(request));
+
+        // Wait for response
+        return await this.waitForResponse(conversation, timeout);
+    }
+
+    /**
+     * Send a plain text message to an agent and wait for the reply.
+     *
+     * @param agentAddress - The target agent's wallet address
+     * @param text - The message text
+     * @param timeout - Timeout in ms (default: 30000)
+     * @returns TaskResult with the reply
+     */
+    public async chat(
+        agentAddress: string,
+        text: string,
+        timeout: number = 30000
+    ): Promise<TaskResult> {
+        const conversation = await this.client.conversations.newDmWithIdentifier({
+            identifier: agentAddress,
+            identifierKind: 0
+        });
+
+        await conversation.send(text);
+
+        return await this.waitForResponse(conversation, timeout);
+    }
+
+    /**
+     * Wait for a response message from the agent on a conversation.
+     */
+    private async waitForResponse(
+        conversation: any,
+        timeout: number
+    ): Promise<TaskResult> {
+        return new Promise<TaskResult>(async (resolve) => {
+            const timer = setTimeout(() => {
+                resolve({
+                    success: false,
+                    error: `Timeout: No response after ${timeout}ms`
+                });
+            }, timeout);
+
+            try {
+                const stream = await conversation.stream();
+
+                for await (const message of stream) {
+                    // Skip our own messages
+                    if ((message as any).senderInboxId === this.client.inboxId) continue;
+
+                    clearTimeout(timer);
+
+                    const content = (message as any).content;
+                    if (typeof content !== 'string') {
+                        resolve({ success: true, raw: String(content) });
+                        return;
+                    }
+
+                    // Try to parse as JSON
+                    try {
+                        const json = JSON.parse(content);
+
+                        // 402 Payment Required
+                        if (json.type === "PAYMENT_REQUIRED") {
+                            resolve({
+                                success: false,
+                                paymentRequired: json.payment,
+                                raw: content
+                            });
+                            return;
+                        }
+
+                        // JSON-RPC error
+                        if (json.error) {
+                            resolve({
+                                success: false,
+                                error: json.error.message || JSON.stringify(json.error),
+                                raw: content
+                            });
+                            return;
+                        }
+
+                        // JSON-RPC success
+                        if (json.result !== undefined) {
+                            resolve({
+                                success: true,
+                                result: json.result,
+                                raw: content
+                            });
+                            return;
+                        }
+
+                        // Generic JSON response
+                        resolve({ success: true, result: json, raw: content });
+                        return;
+                    } catch {
+                        // Plain text response
+                        resolve({ success: true, result: content, raw: content });
+                        return;
+                    }
+                }
+            } catch (err: any) {
+                clearTimeout(timer);
+                resolve({
+                    success: false,
+                    error: err.message || "Stream error"
+                });
+            }
+        });
+    }
+
+    /**
+     * Stream all incoming messages across all conversations.
+     * Calls the callback for each incoming message (skips own messages).
+     * Runs in the background — returns immediately.
+     *
+     * @param onMessage - Callback receiving (senderAddress, content, conversationId)
+     */
+    public async streamAllMessages(
+        onMessage: (senderAddress: string, content: string, conversationId: string) => void
+    ): Promise<void> {
+        // Sync all conversations and messages first
+        await this.client.conversations.syncAll();
+
+        const stream = await this.client.conversations.streamAllMessages({
+            consentStates: [ConsentState.Allowed, ConsentState.Unknown, ConsentState.Denied]
+        });
+
+        // Run in background (don't await)
+        (async () => {
+            try {
+                for await (const message of stream) {
+                    // Skip our own messages
+                    if ((message as any).senderInboxId === this.client.inboxId) continue;
+
+                    const content = (message as any).content;
+                    const conversationId = (message as any).conversationId || '';
+                    const senderAddress = (message as any).senderInboxId || 'unknown';
+
+                    onMessage(senderAddress, String(content), conversationId);
+                }
+            } catch (err: any) {
+                console.error('[OpenAgentClient] Stream error:', err.message);
+            }
+        })();
+    }
+}

package/src/index.ts

@@ -9,6 +9,7 @@ export * from './skills/payment.js';
 export * from './skills/discovery.js';
 export * from './skills/job.js';
 export * from './registry.js';
+export * from './client.js';
 
 export interface OpenAgentConfig {
     signer?: Signer;