@gholl-studio/pier-connector 0.2.29 → 0.2.31

package/openclaw.plugin.json

@@ -59,6 +59,12 @@
                 "type": "string",
                 "default": "",
                 "description": "(Optional) Wallet address or account ID for receiving rewards"
+            },
+            "capabilities": {
+                "type": "array",
+                "items": { "type": "string" },
+                "default": ["translation", "code-execution", "reasoning", "vision"],
+                "description": "List of AI capabilities this node supports (e.g., translation, gpu:4090)"
             }
         }
     },
@@ -102,6 +108,10 @@
         "walletAddress": {
             "label": "Wallet Address (Rewards)",
             "placeholder": "0x..."
+        },
+        "capabilities": {
+            "label": "Capabilities",
+            "placeholder": "translation, reasoning, ..."
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.2.29",
+    "version": "0.2.31",
     "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",
@@ -19,8 +19,11 @@
         ]
     },
     "scripts": {
-        "start": "node src/index.js",
-        "dev": "node --watch src/index.js"
+        "dev": "vite",
+        "build": "tsc -b && vite build",
+        "lint": "eslint .",
+        "preview": "vite preview",
+        "test:watch": "node --watch test-standalone.js"
     },
     "keywords": [
         "openclaw",
@@ -31,6 +34,7 @@
     ],
     "license": "MIT",
     "dependencies": {
+        "pier-sdk": "file:../packages/pier-sdk",
         "@nats-io/jetstream": "^3.3.1",
         "@nats-io/transport-node": "^3.0.0",
         "ethers": "^6.16.0",
@@ -44,5 +48,8 @@
         "openclaw": {
             "optional": true
         }
+    },
+    "devDependencies": {
+        "dotenv": "^17.3.1"
     }
 }

package/src/index.js

@@ -8,13 +8,12 @@
  *  4. A command ("/pier") for checking connection status
  */
 
-import { createNatsConnection, drainConnection } from './nats-client.js';
+import { PierClient, protocol } from 'pier-sdk';
+const { createRequestPayload, createResultPayload, createErrorPayload } = protocol;
 import { parseJob, safeRespond, truncate } from './job-handler.js';
-import { createRequestPayload, createResultPayload, createErrorPayload } from './protocol.js';
 import { DEFAULTS } from './config.js';
 import { jetstream, jetstreamManager, AckPolicy, DeliverPolicy } from '@nats-io/jetstream';
 import inquirer from 'inquirer';
-import { ethers } from 'ethers';
 import fs from 'fs';
 import path from 'path';
 
@@ -69,6 +68,7 @@ export default function register(api) {
             queueGroup: merged.queueGroup || DEFAULTS.QUEUE_GROUP,
             agentId: merged.agentId || DEFAULTS.AGENT_ID,
             walletAddress: merged.walletAddress || DEFAULTS.WALLET_ADDRESS,
+            capabilities: merged.capabilities || ['translation', 'code-execution', 'reasoning', 'vision'],
         };
     }
 
@@ -80,6 +80,11 @@ export default function register(api) {
         constructor(config) {
             this.config = config;
             this.accountId = config.accountId;
+            this.client = new PierClient({ 
+                apiUrl: config.pierApiUrl,
+                natsUrl: config.natsUrl, 
+                logger 
+            });
             this.nc = null;
             this.js = null;
             this.jsm = null;
@@ -95,26 +100,37 @@ export default function register(api) {
             this.connectedAt = null;
         }
 
+        async init() {
+            try {
+                this.nc = await this.client.connectNats();
+                this.js = jetstream(this.nc);
+                this.jsm = await jetstreamManager(this.nc);
+                
+                this.connectedAt = new Date();
+                this.connectionStatus = 'connected';
+                
+                // Subscribe to tasks
+                await this.subscribeToTasks();
+                
+                // Start heartbeat
+                this.startHeartbeat();
+                
+                return true;
+            } catch (err) {
+                this.connectionStatus = 'error';
+                logger.error(`[pier-connector] Account ${this.accountId} failed to connect: ${err.message}`);
+                return false;
+            }
+        }
+
         async heartbeat() {
             if (!this.config.nodeId || !this.config.secretKey) return null;
             try {
-                const resp = await fetch(`${this.config.pierApiUrl}/nodes/heartbeat`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        node_id: this.config.nodeId,
-                        secret_key: this.config.secretKey,
-                        capabilities: ['translation', 'code-execution', 'reasoning', 'vision'],
-                        description: `OpenClaw Node (${this.config.nodeId.substring(0, 8)}) [${this.accountId}]`,
-                    }),
-                });
-
-                if (!resp.ok) {
-                    const errText = await resp.text();
-                    throw new Error(`Heartbeat failed (${resp.status}): ${errText}`);
-                }
-
-                const data = await resp.json();
+                const data = await this.client.heartbeat(
+                    this.config.nodeId,
+                    this.config.secretKey,
+                    this.config.capabilities
+                );
                 this.lastHeartbeatError = null;
                 return data.nats_config || null;
             } catch (err) {
@@ -125,28 +141,7 @@ export default function register(api) {
         }
 
         async claimJob(jobId) {
-            try {
-                const resp = await fetch(`${this.config.pierApiUrl}/jobs/${jobId}/claim`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.config.secretKey}`,
-                        'X-Node-Id': this.config.nodeId
-                    }
-                });
-
-                if (!resp.ok) {
-                    if (resp.status === 409) {
-                        logger.warn(`[pier-connector][${this.accountId}] 🚫 Job ${jobId} already claimed.`);
-                        return { ok: false, alreadyClaimed: true };
-                    }
-                    const errData = await resp.json().catch(() => ({}));
-                    return { ok: false, error: errData.error || resp.statusText };
-                }
-                return { ok: true };
-            } catch (err) {
-                return { ok: false, error: err.message };
-            }
+            return await this.client.claimJob(jobId, this.config.nodeId, this.config.secretKey);
         }
 
     /**
@@ -416,15 +411,17 @@ export default function register(api) {
             let finalText = job.task;
             if (!isTargeted) {
                 finalText = `【PIER MARKETPLACE OPEN JOB】\nJob ID: ${job.id}\nTask: ${job.task}\n\n=== CRITICAL ===\nYou MUST use \`pier_bid_task\` to bid. Do not solve directly.`;
+            } else {
+                // Only subscribe to chat for targeted/assigned jobs
+                await this.subscribeToJobMessages(job.id);
             }
 
-            await this.subscribeToJobMessages(job.id);
             await this.receiveIncoming({
                 accountId: this.accountId,
                 senderId: `pier:${senderCore}`,
                 text: finalText,
             }, job.id);
-            
+
             this.isBusy = false;
         }
 
@@ -460,30 +457,10 @@ export default function register(api) {
         }
 
         async autoRegister() {
-            const wallet = new ethers.Wallet(this.config.privateKey);
-            const address = wallet.address;
-            
-            const challengeRes = await fetch(`${this.config.pierApiUrl}/auth/challenge?wallet_address=${address}`);
-            const { challenge } = await challengeRes.json();
-            const signature = await wallet.signMessage(challenge);
-
-            const loginRes = await fetch(`${this.config.pierApiUrl}/auth/login`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ wallet_address: address, challenge, signature })
-            });
-            const { api_key } = await loginRes.json();
-
             const hostName = `${api?.getRuntimeInfo?.()?.hostname ?? 'Auto'}-${this.accountId}`;
-            const regRes = await fetch(`${this.config.pierApiUrl}/nodes/register`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${api_key}` },
-                body: JSON.stringify({ wallet_address: address, name: hostName })
-            });
-            const { id, secret_key } = await regRes.json();
-
-            this.config.nodeId = id;
-            this.config.secretKey = secret_key;
+            const { nodeId, secretKey } = await this.client.autoRegister(this.config.privateKey, hostName);
+            this.config.nodeId = nodeId;
+            this.config.secretKey = secretKey;
         }
 
         async start() {
@@ -599,18 +576,24 @@ export default function register(api) {
                     try {
                         const replySubject = `chat.${jobId}`;
                         
-                        const chatPayload = {
-                            id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                            job_id: jobId,
-                            sender_id: robot.config.nodeId || 'anonymous',
-                            sender_type: 'node',
-                            content: text,
-                            created_at: new Date().toISOString(),
-                            auth_token: robot.config.secretKey
-                        };
-                        
-                        await robot.js.publish(replySubject, new TextEncoder().encode(JSON.stringify(chatPayload)));
-                        logger.info(`[pier-connector][${accountId}] 💬 Agent reply published to NATS for job ${jobId} (Subject: ${replySubject})`);
+                        // Only publish replies for jobs assigned to this robot
+                        if (!metadata?.isTargeted) {
+                            logger.debug(`[pier-connector][${accountId}] 🫨 Suppressing reply for non-assigned job ${jobId}`);
+                        } else {
+                            const chatPayload = {
+                                id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
+                                job_id: jobId,
+                                sender_id: robot.config.nodeId || 'anonymous',
+                                sender_name: accountId,
+                                sender_type: 'node',
+                                content: text,
+                                created_at: new Date().toISOString(),
+                                auth_token: robot.config.secretKey
+                            };
+                            
+                            await robot.js.publish(replySubject, new TextEncoder().encode(JSON.stringify(chatPayload)));
+                            logger.info(`[pier-connector][${accountId}] 💬 Agent reply published to NATS for job ${jobId} (Subject: ${replySubject})`);
+                        }
                     } catch (err) {
                         logger.error(`[pier-connector][${accountId}] Failed to publish reply: ${err.message}`);
                     }
@@ -745,8 +728,9 @@ export default function register(api) {
                 },
                 required: ['jobId', 'text']
             },
-            async execute(_id, params) {
+            async execute(_id, params, ctx) {
                 const accountId = params.accountId || 'default';
+                logger.info(`[pier-connector] 🛠️ Tool called: pier_chat | jobId=${params.jobId} | accountId=${accountId}`);
                 const robot = instances.get(accountId) || instances.values().next().value;
                 if (!robot || robot.connectionStatus !== 'connected') {
                     return { content: [{ type: 'text', text: 'Error: Robot not connected' }] };
@@ -754,10 +738,20 @@ export default function register(api) {
 
                 try {
                     const subject = `chat.${params.jobId}`;
+                    let metadata = robot.activeNodeJobs.get(params.jobId);
+                    
+                    if (!metadata && ctx.to) {
+                        const toId = ctx.to.replace(/^pier:/, '');
+                        metadata = robot.activeNodeJobs.get(toId);
+                    }
+                    
+                    const jobId = metadata?.pierJobId || params.jobId;
+
                     const payload = {
                         id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                        job_id: params.jobId,
+                        job_id: jobId,
                         sender_id: robot.config.nodeId,
+                        sender_name: accountId,
                         sender_type: 'node',
                         content: params.text,
                         created_at: new Date().toISOString(),
@@ -837,6 +831,41 @@ export default function register(api) {
         comment: { type: 'string', description: 'A short review' }
     }, 'user');
 
+    registerSystemActionTool('pier_reject_task', 'Reject an offered task from the employer in the current chat', 'task_reject', {
+        reason: { type: 'string', description: 'Reason for rejection' }
+    });
+
+    registerSystemActionTool('pier_fail_task', 'Report that the task has failed during execution', 'task_error', {
+        error: { type: 'string', description: 'Description of the error' }
+    });
+    
+    registerSystemActionTool('pier_cancel_task', 'Cancel a previously proposed task', 'task_cancel', {
+        reason: { type: 'string', description: 'Reason for cancellation' }
+    }, 'user');
+
+    api.registerTool({
+        name: 'pier_get_profile',
+        description: 'Get the current Pier profile, balance, and node stats.',
+        parameters: {
+            type: 'object',
+            properties: {
+                accountId: { type: 'string' }
+            }
+        },
+        async execute(_id, params) {
+            const accountId = params.accountId || 'default';
+            const robot = instances.get(accountId) || instances.values().next().value;
+            if (!robot) return { content: [{ type: 'text', text: 'Error: Robot not found' }] };
+
+            try {
+                const profile = await robot.client.getUserProfile(robot.config.secretKey);
+                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }] };
+            } catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
+            }
+        }
+    }, { optional: true });
+
     // ── 4. Register /pier status command ───────────────────────────────
 
     api.registerCommand({
@@ -920,55 +949,35 @@ export default function register(api) {
                             { type: 'input', name: 'pierApiUrl', message: 'Pier API URL:', default: currentConfig.pierApiUrl },
                             { type: 'input', name: 'nodeId', message: 'Bot Node ID (UUID):', default: finalNodeId },
                             { type: 'password', name: 'secretKey', message: 'Bot Secret Key:', default: finalSecretKey },
-                            { type: 'input', name: 'walletAddress', message: 'Your Wallet Address (for payout):', default: finalWallet }
+                            { type: 'input', name: 'walletAddress', message: 'Your Wallet Address (for payout):', default: finalWallet },
+                            { type: 'input', name: 'capabilities', message: 'Capabilities (comma-separated):', default: (currentConfig.capabilities || []).join(', ') }
                         ]);
                         finalNodeId = manualAnswers.nodeId;
                         finalSecretKey = manualAnswers.secretKey;
                         finalWallet = manualAnswers.walletAddress;
+                        currentConfig.capabilities = manualAnswers.capabilities ? manualAnswers.capabilities.split(',').map(s => s.trim()) : currentConfig.capabilities;
                         currentConfig.pierApiUrl = manualAnswers.pierApiUrl;
                     } else if (setupMethod === 'auto') {
                         const autoAnswers = await inquirer.prompt([
                             { type: 'input', name: 'pierApiUrl', message: 'Pier API URL:', default: currentConfig.pierApiUrl },
-                            { type: 'password', name: 'privateKey', message: 'Your Wallet Private Key (Hex, 0x...):', default: finalPrivateKey }
+                            { type: 'password', name: 'privateKey', message: 'Your Wallet Private Key (Hex, 0x...):', default: finalPrivateKey },
+                            { type: 'input', name: 'capabilities', message: 'Capabilities (comma-separated):', default: (currentConfig.capabilities || []).join(', ') }
                         ]);
                         console.log('\n\x1b[36mRegistering your node...\x1b[0m');
                         try {
-                            const wallet = new ethers.Wallet(autoAnswers.privateKey);
-                            console.log(`\x1b[32m✔ Loaded wallet: ${wallet.address}\x1b[0m`);
-                            finalWallet = finalWallet || wallet.address;
-                            finalPrivateKey = autoAnswers.privateKey;
-                            currentConfig.pierApiUrl = autoAnswers.pierApiUrl;
-
-                            const challengeRes = await fetch(`${currentConfig.pierApiUrl}/auth/challenge?wallet_address=${wallet.address}`);
-                            if (!challengeRes.ok) throw new Error("Failed to get challenge");
-                            const { challenge } = await challengeRes.json();
-
-                            const signature = await wallet.signMessage(challenge);
-
-                            const loginRes = await fetch(`${currentConfig.pierApiUrl}/auth/login`, {
-                                method: 'POST',
-                                headers: { 'Content-Type': 'application/json' },
-                                body: JSON.stringify({ wallet_address: wallet.address, challenge, signature })
-                            });
-                            if (!loginRes.ok) throw new Error("Failed to login");
-                            const { api_key } = await loginRes.json();
-
+                            const tempClient = new PierClient({ apiUrl: autoAnswers.pierApiUrl });
                             const hostName = api?.getRuntimeInfo?.()?.hostname ?? 'Auto-Node';
-                            const regRes = await fetch(`${currentConfig.pierApiUrl}/nodes/register`, {
-                                method: 'POST',
-                                headers: { 
-                                    'Content-Type': 'application/json',
-                                    'Authorization': `Bearer ${api_key}`
-                                },
-                                body: JSON.stringify({ wallet_address: wallet.address, name: hostName })
-                            });
                             
-                            if (!regRes.ok) throw new Error(`Failed to auto-register node (${regRes.status})`);
-                            const { id, secret_key } = await regRes.json();
+                            const { nodeId, secretKey, walletAddress } = await tempClient.autoRegister(autoAnswers.privateKey, hostName);
+
+                            finalWallet = finalWallet || walletAddress;
+                            finalPrivateKey = autoAnswers.privateKey;
+                            currentConfig.pierApiUrl = autoAnswers.pierApiUrl;
+                            currentConfig.capabilities = autoAnswers.capabilities ? autoAnswers.capabilities.split(',').map(s => s.trim()) : currentConfig.capabilities;
+                            finalNodeId = nodeId;
+                            finalSecretKey = secretKey;
 
-                            finalNodeId = id;
-                            finalSecretKey = secret_key;
-                            console.log(`\x1b[32m✔ Node registered automatically! Node ID: ${id}\x1b[0m`);
+                            console.log(`\x1b[32m✔ Node registered automatically! Node ID: ${nodeId}\x1b[0m`);
                         } catch (err) {
                             console.error(`\x1b[31m✖ Failed to auto-register: ${err.message}\x1b[0m`);
                             return; // Stop setup
@@ -1014,7 +1023,8 @@ export default function register(api) {
                         nodeId: finalNodeId,
                         secretKey: finalSecretKey,
                         walletAddress: finalWallet,
-                        agentId: finalAgentId
+                        agentId: finalAgentId,
+                        capabilities: currentConfig.capabilities
                     };
                     
                     if (setupMethod === 'auto') {

package/src/job-handler.js

@@ -20,7 +20,8 @@
  * @param {object} logger
  * @returns {{ ok: true, job: object } | { ok: false, error: string }}
  */
-import { normalizeInboundPayload } from './protocol.js';
+import { protocol } from 'pier-sdk';
+const { normalizeInboundPayload } = protocol;
 
 export function parseJob(msg, logger) {
     let raw;

package/src/compression.js

@@ -1,12 +0,0 @@
-/**
- * Simple pass-through utility for messaging.
- * Compression was removed for simplicity and ease of debugging.
- */
-
-export function compress(text) {
-  return text;
-}
-
-export function decompress(content) {
-  return content;
-}

package/src/nats-client.js

@@ -1,75 +0,0 @@
-/**
- * NATS WebSocket connection manager.
- *
- * Uses `wsconnect` from @nats-io/transport-node to establish a
- * WebSocket connection to the NATS server.
- */
-
-import { wsconnect } from '@nats-io/transport-node';
-import { jetstream } from '@nats-io/jetstream';
-
-/**
- * Create and return a NATS connection over WebSocket.
- *
- * @param {string}  url    – WebSocket URL, e.g. "wss://pier.gholl.com/nexus"
- * @param {object}  logger – OpenClaw logger (api.logger)
- * @returns {Promise<import('@nats-io/transport-node').NatsConnection>}
- */
-export async function createNatsConnection(url, logger) {
-    logger.info(`[pier-connector] Connecting to NATS at ${url} …`);
-
-    const nc = await wsconnect({ servers: url });
-
-    logger.info('[pier-connector] ✔ NATS connected successfully');
-
-    // ---------- lifecycle event monitoring ----------
-
-    // Fired when the client is disconnected from the server
-    (async () => {
-        for await (const status of nc.status()) {
-            switch (status.type) {
-                case 'disconnect':
-                    logger.warn(`[pier-connector] NATS disconnected: ${status.data}`);
-                    break;
-
-                case 'reconnect':
-                    logger.info(`[pier-connector] NATS reconnected to ${status.data}`);
-                    break;
-
-                case 'reconnecting':
-                    logger.warn('[pier-connector] NATS reconnecting …');
-                    break;
-
-                case 'error':
-                    logger.error(`[pier-connector] NATS error: ${status.data}`);
-                    break;
-
-                case 'update':
-                    logger.info(`[pier-connector] NATS cluster update: ${JSON.stringify(status.data)}`);
-                    break;
-
-                default:
-                    logger.info(`[pier-connector] NATS status: ${status.type}`);
-            }
-        }
-    })();
-
-    return nc;
-}
-
-/**
- * Gracefully drain (flush pending + close) a NATS connection.
- *
- * @param {import('@nats-io/transport-node').NatsConnection} nc
- * @param {object} logger
- */
-export async function drainConnection(nc, logger) {
-    if (!nc) return;
-    try {
-        logger.info('[pier-connector] Draining NATS connection …');
-        await nc.drain();
-        logger.info('[pier-connector] ✔ NATS connection drained');
-    } catch (err) {
-        logger.error(`[pier-connector] Error draining NATS: ${err.message}`);
-    }
-}

package/src/protocol.js

@@ -1,142 +0,0 @@
-/**
- * Protocol Definitions for Pier Connector
- * 
- * Standardizes outbound and inbound JSON boundaries for NATS.
- */
-
-export const PROTOCOL_VERSION = '1.1';
-
-/**
- * Creates a standard task request payload to send to Pier.
- * 
- * @param {object} params
- * @param {string} params.task
- * @param {string} [params.systemPrompt]
- * @param {number} [params.timeoutMs]
- * @param {object} [params.meta]
- * @param {string} [params.targetNodeId]
- * @param {string} [params.parentJobId]
- * @returns {object}
- */
-export function createRequestPayload({ task, systemPrompt, timeoutMs, meta, targetNodeId, parentJobId }) {
-    return {
-        version: PROTOCOL_VERSION,
-        id: crypto.randomUUID(),
-        type: 'task', // Changed from task_request to task to align with backend models
-        task,
-        systemPrompt,
-        timeoutMs: timeoutMs || 60000,
-        meta: meta || {},
-        targetNodeId: targetNodeId || null,
-        parentJobId: parentJobId || null,
-    };
-}
-
-/**
- * Creates a standard task result payload to respond to Pier.
- * 
- * @param {object} params
- * @param {string} params.id
- * @param {string} params.reply
- * @param {number} [params.latencyMs]
- * @param {string} [params.workerId]
- * @param {string} [params.walletAddress]
- * @returns {object}
- */
-export function createResultPayload({ id, reply, latencyMs, workerId, walletAddress }) {
-    return {
-        version: PROTOCOL_VERSION,
-        id,
-        type: 'task_result',
-        ok: true,
-        result: reply,
-        latencyMs,
-        worker: {
-            id: workerId || 'anonymous-worker',
-            wallet: walletAddress || null,
-        },
-    };
-}
-
-/**
- * Creates a standard task error payload to respond to Pier.
- * 
- * @param {object} params
- * @param {string} params.id
- * @param {string} params.errorCode
- * @param {string} params.errorMessage
- * @param {string} [params.workerId]
- * @param {string} [params.walletAddress]
- * @returns {object}
- */
-export function createErrorPayload({ id, errorCode, errorMessage, workerId, walletAddress }) {
-    return {
-        version: PROTOCOL_VERSION,
-        id,
-        type: 'task_error',
-        ok: false,
-        error: {
-            code: errorCode,
-            message: errorMessage,
-        },
-        worker: {
-            id: workerId || 'anonymous-worker',
-            wallet: walletAddress || null,
-        },
-    };
-}
-
-/**
- * Validate and normalize an incoming NATS payload to a standard job format.
- * 
- * @param {object} payload
- * @returns {{ ok: true, job: object } | { ok: false, error: string }}
- */
-export function normalizeInboundPayload(payload) {
-    // If it's a strict v1.1+ protocol request
-    if (payload.type === 'task' || payload.type === 'task_request') {
-        if (!payload.task) {
-            return { ok: false, error: 'Missing "task" field in task payload' };
-        }
-        return {
-            ok: true,
-            job: {
-                id: payload.id || crypto.randomUUID(),
-                task: payload.task,
-                systemPrompt: payload.systemPrompt,
-                meta: payload.meta || {},
-                targetNodeId: payload.targetNodeId || null,
-                parentJobId: payload.parentJobId || null,
-            },
-        };
-    }
-
-    // Support for Join-Chat wakeup signals (BUG-26/29)
-    if (payload.type === 'wakeup') {
-        const jobId = payload.jobId || payload.id;
-        if (!jobId) return { ok: false, error: 'Missing jobId in wakeup payload' };
-        return {
-            ok: true,
-            job: {
-                id: jobId,
-                type: 'wakeup'
-            }
-        };
-    }
-
-    // Fallback for legacy / generic JSON structures
-    const task = payload.task ?? payload.prompt ?? payload.content ?? '';
-    if (!task) {
-        return { ok: false, error: 'Missing "task" or "prompt" field in payload' };
-    }
-
-    return {
-        ok: true,
-        job: {
-            id: payload.id || crypto.randomUUID(),
-            task,
-            systemPrompt: payload.systemPrompt,
-            meta: payload.meta || {},
-        },
-    };
-}