@gholl-studio/pier-connector 0.0.1 → 0.0.3

package/README.md

@@ -17,7 +17,7 @@
 - **Pier Account**: A valid account with access to the job marketplace
 - **Network**: Stable internet connection
 
-> 💡 **Note**: The plugin handles all connection logic internally. You only need to configure your **Pier API Token** in the settings. No external message brokers (like NATS) or custom server setups are required.
+> 💡 **Note**: The plugin handles registration and heartbeat logic internally. You only need to configure your **Pier API URL/Key** in the settings. The plugin will automatically negotiate NATS connection details with the backend.
 
 ## Installation
 
@@ -34,9 +34,21 @@ openclaw plugins enable pier-connector
 
 Restart the OpenClaw Gateway.
 
-## Configuration
+Restart the OpenClaw Gateway.
+
+## ⚙️ How to Configure
+
+There are two ways to configure the plugin:
+
+### 1. Interactive CLI (Recommended)
+Run the following command in your terminal:
+```bash
+openclaw pier setup
+```
+This will guide you through setting up your API URL, Key, and Wallet.
 
-Configure via `plugins.entries.pier-connector.config`:
+### 2. Manual Config
+Add the following to your `openclaw.config.json` under `plugins.entries.pier-connector.config`:
 
 ```json
 {
@@ -45,12 +57,9 @@ Configure via `plugins.entries.pier-connector.config`:
       "pier-connector": {
         "enabled": true,
         "config": {
-          "natsUrl": "wss://pier.gholl.com/nexus",
-          "subject": "jobs.worker",
-          "publishSubject": "jobs.submit",
-          "queueGroup": "openclaw-workers",
-          "workerId": "agent-001",
-          "walletAddress": "0xABC123"
+          "apiUrl": "https://pier.gholl.com",
+          "apiKey": "your-api-key-here",
+          "walletAddress": "0xYourWalletAddress"
         }
       }
     }
@@ -58,14 +67,14 @@ Configure via `plugins.entries.pier-connector.config`:
 }
 ```
 
-| Option           | Default                        | Description                          |
-|------------------|--------------------------------|--------------------------------------|
-| `natsUrl`        | `wss://pier.gholl.com/nexus`   | NATS WebSocket server URL            |
-| `subject`        | `jobs.worker`                  | Subject to subscribe for incoming jobs |
-| `publishSubject` | `jobs.submit`                  | Subject for outbound task publishing |
-| `queueGroup`     | `openclaw-workers`             | NATS Queue Group for load balancing  |
-| `workerId`       | `""`                           | Unique identifier for this agent worker |
-| `walletAddress`  | `""`                           | Wallet address for receiving rewards |
+| Option          | Default                      | Description                                      |
+|-----------------|------------------------------|--------------------------------------------------|
+| `apiUrl`        | `https://pier.gholl.com`     | Pier Backend API Base URL                        |
+| `apiKey`        | `""`                         | Your User API Key for platform authentication    |
+| `nodeId`        | `""`                         | (Auto-generated) Unique UUID for this node       |
+| `secretKey`     | `""`                         | (Auto-generated) Secret key for pulse verification |
+| `walletAddress` | `""`                         | Wallet address for receiving job rewards         |
+| `natsUrl`       | `""`                         | (Optional) Manual NATS override                  |
 
 ## How It Works
 
@@ -119,8 +128,8 @@ Use `/pier` in any OpenClaw channel to check connector status.
   "result": "The AI's generated response",
   "latencyMs": 1450,
   "worker": {
-    "id": "agent-001",
-    "wallet": "0xABC123"
+    "id": "uuid-node",
+    "wallet": "0xYourWalletAddress"
   }
 }
 ```
@@ -138,8 +147,8 @@ Use `/pier` in any OpenClaw channel to check connector status.
     "message": "Error details"
   },
   "worker": {
-    "id": "agent-001",
-    "wallet": "0xABC123"
+    "id": "uuid-node",
+    "wallet": "0xYourWalletAddress"
   }
 }
 ```

package/openclaw.plugin.json

@@ -10,10 +10,25 @@
         "type": "object",
         "additionalProperties": false,
         "properties": {
+            "pierApiUrl": {
+                "type": "string",
+                "default": "https://pier-connector.gholl.com/api/v1",
+                "description": "Pier API Endpoint (from Website)"
+            },
+            "nodeId": {
+                "type": "string",
+                "default": "",
+                "description": "Bot Node ID (obtain from pier-connector.gholl.com)"
+            },
+            "secretKey": {
+                "type": "string",
+                "default": "",
+                "description": "Bot Secret Key (obtain from pier-connector.gholl.com)"
+            },
             "natsUrl": {
                 "type": "string",
                 "default": "wss://pier.gholl.com/nexus",
-                "description": "NATS WebSocket server URL"
+                "description": "NATS WebSocket server URL (Overrides API dynamic config if set)"
             },
             "subject": {
                 "type": "string",
@@ -30,11 +45,6 @@
                 "default": "openclaw-workers",
                 "description": "NATS Queue Group to join for load balancing tasks"
             },
-            "workerId": {
-                "type": "string",
-                "default": "",
-                "description": "(Optional) Unique identifier for this agent worker"
-            },
             "walletAddress": {
                 "type": "string",
                 "default": "",
@@ -43,26 +53,34 @@
         }
     },
     "uiHints": {
+        "pierApiUrl": {
+            "label": "Pier API URL",
+            "placeholder": "https://pier-connector.gholl.com/api/v1"
+        },
+        "nodeId": {
+            "label": "Bot Node ID",
+            "placeholder": "uuid-..."
+        },
+        "secretKey": {
+            "label": "Bot Secret Key (Secret)",
+            "placeholder": "sk_..."
+        },
         "natsUrl": {
-            "label": "NATS WebSocket URL",
+            "label": "NATS WebSocket URL (Override)",
             "placeholder": "wss://pier.gholl.com/nexus"
         },
         "subject": {
-            "label": "Subscribe Subject (incoming jobs)",
+            "label": "Subscribe Subject",
             "placeholder": "jobs.worker"
         },
         "publishSubject": {
-            "label": "Publish Subject (outbound tasks)",
+            "label": "Publish Subject",
             "placeholder": "jobs.submit"
         },
         "queueGroup": {
-            "label": "Queue Group (Load Balancing)",
+            "label": "Queue Group",
             "placeholder": "openclaw-workers"
         },
-        "workerId": {
-            "label": "Worker ID",
-            "placeholder": "agent-001"
-        },
         "walletAddress": {
             "label": "Wallet Address (Rewards)",
             "placeholder": "0x..."

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "description": "OpenClaw plugin that connects to the Pier job marketplace. Automatically fetches, executes, and reports distributed tasks for rewards.",
     "type": "module",
     "main": "src/index.js",
@@ -31,7 +31,8 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@nats-io/transport-node": "^3.0.0"
+        "@nats-io/transport-node": "^3.0.0",
+        "inquirer": "^13.3.0"
     },
     "peerDependencies": {
         "openclaw": ">=2.0.0"
@@ -41,4 +42,4 @@
             "optional": true
         }
     }
-}
+}

package/src/config.js

@@ -5,7 +5,10 @@
  */
 
 export const DEFAULTS = Object.freeze({
-    /** NATS WebSocket server URL */
+    /** Pier Backend API Base URL */
+    PIER_API_URL: 'https://pier-connector.gholl.com/api/v1',
+
+    /** NATS WebSocket server URL (usually provided by Heartbeat) */
     NATS_URL: 'wss://pier.gholl.com/nexus',
 
     /** NATS subject to subscribe for incoming jobs */
@@ -17,8 +20,11 @@ export const DEFAULTS = Object.freeze({
     /** Default Queue Group for processing jobs (prevents duplicate work) */
     QUEUE_GROUP: 'openclaw-workers',
 
-    /** Optional ID to identify this specific worker node */
-    WORKER_ID: '',
+    /** Unique identifier for this agent worker node (UUID) */
+    NODE_ID: '',
+
+    /** Secret key for node authentication and heartbeats */
+    SECRET_KEY: '',
 
     /** Optional Wallet address to receive points/payments for completed tasks */
     WALLET_ADDRESS: '',

package/src/index.js

@@ -12,6 +12,7 @@ import { createNatsConnection, drainConnection } from './nats-client.js';
 import { parseJob, safeRespond, truncate } from './job-handler.js';
 import { createRequestPayload, createResultPayload, createErrorPayload } from './protocol.js';
 import { DEFAULTS } from './config.js';
+import inquirer from 'inquirer';
 
 /**
  * OpenClaw plugin register function.
@@ -41,15 +42,53 @@ export default function register(api) {
     function resolveConfig() {
         const cfg = api.config?.plugins?.entries?.['pier-connector']?.config ?? {};
         return {
+            pierApiUrl: cfg.pierApiUrl || DEFAULTS.PIER_API_URL,
+            nodeId: cfg.nodeId || DEFAULTS.NODE_ID,
+            secretKey: cfg.secretKey || DEFAULTS.SECRET_KEY,
             natsUrl: cfg.natsUrl || DEFAULTS.NATS_URL,
-            subject: cfg.subject || DEFAULTS.SUBJECT,
+            subject: cfg.subject || DEFAULTS.PIER_SUBJECT,
             publishSubject: cfg.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
             queueGroup: cfg.queueGroup || DEFAULTS.QUEUE_GROUP,
-            workerId: cfg.workerId || DEFAULTS.WORKER_ID,
             walletAddress: cfg.walletAddress || DEFAULTS.WALLET_ADDRESS,
         };
     }
 
+    /** Heartbeat timer reference */
+    let heartbeatTimer = null;
+
+    // ── Lifecycle: Heartbeat ──────────────────────────────────────────
+ 
+    /**
+     * Sends a heartbeat to the Pier Backend to stay active in the marketplace.
+     */
+    async function heartbeatNode(config) {
+        if (!config.nodeId || !config.secretKey) return null;
+
+        try {
+            const resp = await fetch(`${config.pierApiUrl}/nodes/heartbeat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    node_id: config.nodeId,
+                    secret_key: config.secretKey,
+                    capabilities: ['translation', 'code-execution', 'reasoning', 'vision'],
+                    description: `OpenClaw Node (${config.nodeId.substring(0, 8)})`,
+                }),
+            });
+
+            if (!resp.ok) {
+                const errText = await resp.text();
+                throw new Error(`Heartbeat failed (${resp.status}): ${errText}`);
+            }
+
+            const data = await resp.json();
+            return data.nats_config || null;
+        } catch (err) {
+            logger.warn(`[pier-connector] Heartbeat failed: ${err.message}`);
+            return null;
+        }
+    }
+
     // ── 1. Register messaging channel ──────────────────────────────────
 
     const pierChannel = {
@@ -96,7 +135,7 @@ export default function register(api) {
                         id: jobId,
                         reply: text,
                         latencyMs: elapsed ? Number(elapsed) : undefined,
-                        workerId: resolveConfig().workerId,
+                        workerId: resolveConfig().nodeId,
                         walletAddress: resolveConfig().walletAddress,
                     });
 
@@ -123,141 +162,142 @@ export default function register(api) {
 
         start: async () => {
             const config = resolveConfig();
-
             logger.info('[pier-connector] 🚀 Starting background service …');
-            logger.info(`[pier-connector]    NATS URL         : ${config.natsUrl}`);
-            logger.info(`[pier-connector]    Subscribe subject : ${config.subject}`);
-            logger.info(`[pier-connector]    Queue Group       : ${config.queueGroup}`);
-            logger.info(`[pier-connector]    Publish subject   : ${config.publishSubject}`);
-            if (config.workerId) logger.info(`[pier-connector]    Worker ID         : ${config.workerId}`);
-            if (config.walletAddress) logger.info(`[pier-connector]    Wallet            : ${config.walletAddress}`);
 
             try {
-                // Connect to NATS via WebSocket
-                nc = await createNatsConnection(config.natsUrl, logger);
+                // 1. Mandatory credentials check
+                if (!config.nodeId || !config.secretKey) {
+                    logger.warn('[pier-connector] ⚠️ Bot Node ID or Secret is missing.');
+                    logger.warn('[pier-connector]    Please run "openclaw pier setup" or go to pier-connector.gholl.com to create a bot.');
+                    connectionStatus = 'error';
+                    return;
+                }
+
+                connectionStatus = 'connecting';
+
+                // 2. Initial Pulse & Config fetch
+                logger.info(`[pier-connector] 💓 Sending initial pulse to ${config.pierApiUrl}...`);
+                const natsUpdate = await heartbeatNode(config);
+                const activeNatsUrl = natsUpdate?.url || config.natsUrl;
+
+                logger.info(`[pier-connector]    Node ID   : ${config.nodeId}`);
+                logger.info(`[pier-connector]    NATS URL  : ${activeNatsUrl}`);
+
+                // 3. Start Heartbeat Timer
+                const runHeartbeat = async () => {
+                    const currentConfig = resolveConfig();
+                    if (!currentConfig.nodeId) return;
+                    await heartbeatNode(currentConfig);
+                };
+                heartbeatTimer = setInterval(runHeartbeat, 60000);
+
+                // 4. Connect to NATS
+                nc = await createNatsConnection(activeNatsUrl, logger);
                 connectionStatus = 'connected';
                 connectedAt = new Date();
 
-                // Subscribe to the jobs channel using a Queue Group to distribute work
-                subscription = nc.subscribe(config.subject, { queue: config.queueGroup });
-                logger.info(
-                    `[pier-connector] ✔ Subscribed to "${config.subject}" (group: "${config.queueGroup}") — waiting for jobs …`,
-                );
-
-                // Async message processing loop
-                (async () => {
-                    for await (const msg of subscription) {
-                        jobsReceived++;
-                        const startTime = performance.now();
-
-                        logger.info(
-                            `[pier-connector] 📨 Job #${jobsReceived} received on "${msg.subject}"`,
-                        );
-
-                        // Parse the incoming job
-                        const parsed = parseJob(msg, logger);
-
-                        if (!parsed.ok) {
-                            jobsFailed++;
-                            safeRespond(
-                                msg,
-                                createErrorPayload({
-                                    id: msg.subject, // Fallback ID
-                                    errorCode: 'PARSE_ERROR',
-                                    errorMessage: parsed.error,
-                                    workerId: config.workerId,
-                                    walletAddress: config.walletAddress,
-                                })
-                            );
-                            continue;
-                        }
+                // 5. Subscribe to Subjects
+                const publicSubject = config.subject;
+                const privateSubject = `jobs.node.${config.nodeId}`;
 
-                        const { job } = parsed;
-                        logger.info(
-                            `[pier-connector] 📋 Job ${job.id}: "${truncate(job.task, 80)}"`,
-                        );
-
-                        // Route the job through OpenClaw's agent via the channel
-                        try {
-                            // Build an inbound message for the channel system
-                            const inbound = {
-                                channelId: 'pier',
-                                accountId: 'default',
-                                senderId: `pier:${job.meta?.sender ?? 'anonymous'}`,
-                                text: job.task,
-                                metadata: {
-                                    pierJobId: job.id,
-                                    pierNatsMsg: msg,
-                                    pierStartTime: startTime,
-                                    pierMeta: job.meta,
-                                },
-                            };
-
-                            // If a system prompt was provided, attach it
-                            if (job.systemPrompt) {
-                                inbound.systemPrompt = job.systemPrompt;
-                            }
+                logger.info(`[pier-connector] 👂 Listening to Marketplace: ${publicSubject}`);
+                logger.info(`[pier-connector] 👂 Listening to Direct Messages: ${privateSubject}`);
 
-                            // Send to OpenClaw's agent pipeline
-                            if (api.runtime?.sendIncoming) {
-                                await api.runtime.sendIncoming(inbound);
-                            } else {
-                                // Fallback: direct agent invocation if sendIncoming is not available
-                                logger.warn(
-                                    '[pier-connector] api.runtime.sendIncoming not available, using direct response',
-                                );
-                                safeRespond(
-                                    msg,
-                                    createErrorPayload({
-                                        id: job.id,
-                                        errorCode: 'RUNTIME_UNAVAILABLE',
-                                        errorMessage: 'Agent runtime not available — plugin may need reconfiguration',
-                                        workerId: config.workerId,
-                                        walletAddress: config.walletAddress,
-                                    })
-                                );
-                                jobsFailed++;
-                            }
-                        } catch (err) {
-                            const elapsed = (performance.now() - startTime).toFixed(1);
-                            jobsFailed++;
-                            logger.error(
-                                `[pier-connector] ✖ Job ${job.id} failed after ${elapsed}ms — ${err.message}`,
-                            );
-                            safeRespond(
-                                msg,
-                                createErrorPayload({
-                                    id: job.id,
-                                    errorCode: 'EXECUTION_FAILED',
-                                    errorMessage: err.message,
-                                    workerId: config.workerId,
-                                    walletAddress: config.walletAddress,
-                                })
-                            );
-                        }
+                // Public pool with load balancing
+                nc.subscribe(publicSubject, { 
+                    queue: config.queueGroup,
+                    callback: (err, msg) => handleMessage(msg)
+                });
+                // Private direct channel (no queue group for broadcast/direct)
+                nc.subscribe(privateSubject, { 
+                    callback: (err, msg) => handleMessage(msg)
+                });
+
+                // Unified Message Handler
+                async function handleMessage(msg) {
+                    const startTime = performance.now();
+                    const rawData = new TextDecoder().decode(msg.data);
+                    
+                    let payload;
+                    try {
+                        payload = JSON.parse(rawData);
+                    } catch (e) {
+                        logger.error(`[pier-connector] Failed to parse JSON: ${rawData.substring(0, 100)}`);
+                        return;
                     }
 
-                    logger.info(
-                        `[pier-connector] Subscription loop ended. ` +
-                        `Total: ${jobsReceived} received, ${jobsCompleted} completed, ${jobsFailed} failed`,
-                    );
-                })();
+                    // V1.1 FEATURE: Task Poisoning / Poaching Protection
+                    if (payload.assigned_node_id && payload.assigned_node_id !== config.nodeId) {
+                        // Silent ignore - don't reply, don't log heavily
+                        return;
+                    }
+
+                    jobsReceived++;
+                    const parsed = parseJob(msg, logger);
+                    if (!parsed.ok) {
+                        jobsFailed++;
+                        logger.error(`[pier-connector] Job parse error: ${parsed.error}`);
+                        safeRespond(msg, createErrorPayload({
+                            id: 'unknown',
+                            errorCode: 'PARSE_ERROR',
+                            errorMessage: parsed.error,
+                            workerId: config.nodeId,
+                            walletAddress: config.walletAddress,
+                        }));
+                        return;
+                    }
+
+                    const { job } = parsed;
+                    logger.info(`[pier-connector] 📥 Received job ${job.id}: "${truncate(job.task, 60)}"`);
+
+                    try {
+                        const inbound = {
+                            channelId: 'pier',
+                            accountId: 'default',
+                            senderId: `pier:${job.meta?.sender ?? 'anonymous'}`,
+                            text: job.task,
+                            metadata: {
+                                pierJobId: job.id,
+                                pierNatsMsg: msg,
+                                pierStartTime: startTime,
+                                pierMeta: job.meta,
+                            },
+                        };
+
+                        if (job.systemPrompt) inbound.systemPrompt = job.systemPrompt;
+
+                        if (api.runtime?.sendIncoming) {
+                            await api.runtime.sendIncoming(inbound);
+                        } else {
+                            throw new Error('Agent runtime not available');
+                        }
+                    } catch (err) {
+                        jobsFailed++;
+                        safeRespond(msg, createErrorPayload({
+                            id: job.id,
+                            errorCode: 'EXECUTION_FAILED',
+                            errorMessage: err.message,
+                            workerId: config.nodeId,
+                            walletAddress: config.walletAddress,
+                        }));
+                    }
+                }
 
                 // Monitor connection closure
                 nc.closed().then((err) => {
                     connectionStatus = 'disconnected';
+                    if (heartbeatTimer) clearInterval(heartbeatTimer);
                     if (err) {
-                        logger.error(
-                            `[pier-connector] NATS connection closed with error: ${err.message}`,
-                        );
+                        logger.error(`[pier-connector] NATS connection closed with error: ${err.message}`);
                     } else {
                         logger.info('[pier-connector] NATS connection closed gracefully');
                     }
                 });
             } catch (err) {
                 connectionStatus = 'error';
+                if (heartbeatTimer) clearInterval(heartbeatTimer);
                 logger.error(`[pier-connector] ✖ Failed to start: ${err.message}`);
-                logger.error(`[pier-connector]   Stack: ${err.stack}`);
+                logger.error(err.stack);
             }
         },
 
@@ -393,6 +433,8 @@ export default function register(api) {
                 text: [
                     `**Pier Connector Status**`,
                     `• Connection: ${connectionStatus}`,
+                    `• Node ID: ${config.nodeId || 'N/A'}`,
+                    `• API URL: ${config.pierApiUrl}`,
                     `• NATS URL: ${config.natsUrl}`,
                     `• Subscribe: ${config.subject}`,
                     `• Publish: ${config.publishSubject}`,
@@ -403,5 +445,79 @@ export default function register(api) {
         },
     });
 
+    // ── 5. Register CLI Setup Command ──────────────────────────────────
+
+    api.registerCli(
+        ({ program }) => {
+            // Find or create the 'pier' command namespace to avoid root conflicts
+            let pier = program.commands.find(c => c.name() === 'pier');
+            if (!pier) {
+                pier = program.command('pier').description('Pier connector commands');
+            }
+
+            pier
+                .command('setup')
+                .description('Interactively configure the Pier connector settings')
+                .action(async () => {
+                    const currentConfig = resolveConfig();
+                    
+                    console.log('\n🚢 \x1b[1m\x1b[36mPier Connector Setup (V1.1)\x1b[0m');
+                    console.log('Please register your bot at \x1b[1m\x1b[33mhttps://pier-connector.gholl.com\x1b[0m first.\n');
+
+                    const answers = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'pierApiUrl',
+                            message: 'Pier API URL:',
+                            default: currentConfig.pierApiUrl,
+                        },
+                        {
+                            type: 'input',
+                            name: 'nodeId',
+                            message: 'Bot Node ID (UUID):',
+                            default: currentConfig.nodeId,
+                        },
+                        {
+                            type: 'password',
+                            name: 'secretKey',
+                            message: 'Bot Secret Key:',
+                            default: currentConfig.secretKey,
+                        },
+                        {
+                            type: 'input',
+                            name: 'walletAddress',
+                            message: 'Your Wallet Address (for payout):',
+                            default: currentConfig.walletAddress,
+                        },
+                    ]);
+
+                    // Determine how to save.
+                    console.log('\n✅ \x1b[32mConfiguration Captured!\x1b[0m\n');
+                    
+                    const newConfigBlock = {
+                        plugins: {
+                            entries: {
+                                "pier-connector": {
+                                    enabled: true,
+                                    config: {
+                                        pierApiUrl: answers.pierApiUrl,
+                                        nodeId: answers.nodeId,
+                                        secretKey: answers.secretKey,
+                                        walletAddress: answers.walletAddress
+                                    }
+                                }
+                            }
+                        }
+                    };
+
+                    console.log('Currently, CLI automatic config writes depend on the framework host.');
+                    console.log('Please ensure your \x1b[1m\x1b[33mopenclaw.config.json\x1b[0m includes the following block:\n');
+                    console.log(JSON.stringify(newConfigBlock, null, 2));
+                    console.log('\nRestart OpenClaw to apply changes.');
+                });
+        },
+        { commands: ['pier'] }
+    );
+
     logger.info('[pier-connector] Plugin registered');
 }

package/src/protocol.js

@@ -14,9 +14,10 @@ export const PROTOCOL_VERSION = '1.0';
  * @param {string} [params.systemPrompt]
  * @param {number} [params.timeoutMs]
  * @param {object} [params.meta]
+ * @param {string} [params.targetNodeId]
  * @returns {object}
  */
-export function createRequestPayload({ task, systemPrompt, timeoutMs, meta }) {
+export function createRequestPayload({ task, systemPrompt, timeoutMs, meta, targetNodeId }) {
     return {
         version: PROTOCOL_VERSION,
         id: crypto.randomUUID(),
@@ -25,6 +26,7 @@ export function createRequestPayload({ task, systemPrompt, timeoutMs, meta }) {
         systemPrompt,
         timeoutMs: timeoutMs || 60000,
         meta: meta || {},
+        targetNodeId: targetNodeId || null,
     };
 }
 
@@ -101,6 +103,7 @@ export function normalizeInboundPayload(payload) {
                 task: payload.task,
                 systemPrompt: payload.systemPrompt,
                 meta: payload.meta || {},
+                targetNodeId: payload.targetNodeId || null,
             },
         };
     }