@gholl-studio/pier-connector 0.3.12 → 0.3.14

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.3.12",
+    "version": "0.3.14",
     "description": "OpenClaw plugin that connects to the Pier job marketplace. Automatically fetches, executes, and reports distributed tasks for rewards.",
     "type": "module",
     "main": "src/index.ts",

package/src/inbound.ts

@@ -19,62 +19,32 @@ export async function handleInbound(
         return;
     }
 
-    // 1. Resolve Global Configuration
+    // 1. Resolve Account-Scoped Configuration
     const rootConfig = api.config || {};
     
-    // 2. Resolve Agent Route via SDK
+    /**
+     * ★ Multi-Account Configuration Isolation: Build account-level ClawdbotConfig
+     * 
+     * In multi-account scenarios, each account can have independent agent bindings.
+     * The SDK's resolveAgentRoute looks into cfg.channels.pier. 
+     * By injecting the current robot's config here, we ensure the SDK finds 
+     * the correct agentId for this specific account.
+     */
+    const accountScopedCfg = {
+        ...rootConfig,
+        channels: { ...rootConfig.channels, pier: robot.config }
+    };
+
+    // 2. Resolve Agent Route via SDK with Scoped Config
     const route = api.runtime.channel.routing.resolveAgentRoute({
-        cfg: rootConfig,
+        cfg: accountScopedCfg,
         channel: 'pier',
         accountId: inbound.accountId,
         peer: { kind: 'direct', id: jobId }
     });
 
-    // 3. Robust Routing Decision Tree
-    let finalAgentId = null;
-    let routingSource = 'unresolved';
-
-    // A. Check explicit account-level binding in plugin local config
-    if (robot.config.agentId && robot.config.agentId !== 'main' && robot.config.agentId !== 'default') {
-        finalAgentId = robot.config.agentId;
-        routingSource = 'plugin-local-config';
-    }
-
-    // B. Check Global Bindings
-    if (!finalAgentId) {
-        const bindings = Array.isArray(rootConfig.bindings) ? rootConfig.bindings : [];
-        const binding = bindings.find((bi: any) => 
-            bi.match?.channel === 'pier' && 
-            (bi.match?.accountId === inbound.accountId || bi.match?.account === inbound.accountId)
-        );
-        if (binding?.agentId && binding.agentId !== 'main') {
-            finalAgentId = binding.agentId;
-            routingSource = 'manual-global-bindings-match';
-        }
-    }
-
-    // C. SDK Routing Result
-    if (!finalAgentId && route.agentId && route.agentId !== 'main' && route.agentId !== 'default') {
-        finalAgentId = route.agentId;
-        routingSource = 'sdk-global-bindings';
-    }
-
-    // D. Name-Matching Fallback
-    if (!finalAgentId && inbound.accountId && inbound.accountId !== 'default' && inbound.accountId !== 'main') {
-        const agents = (rootConfig as any).agents?.list || {};
-        const agentExists = Array.isArray(agents) ? agents.some((a: any) => a.id === inbound.accountId) : !!agents[inbound.accountId];
-        
-        if (agentExists) {
-            finalAgentId = inbound.accountId;
-            routingSource = 'account-agent-name-match';
-        }
-    }
-
-    // E. Ultimate Fallback
-    if (!finalAgentId) {
-        finalAgentId = route.agentId || 'main';
-        routingSource = route.agentId ? 'sdk-default-fallback' : 'hardcoded-main-fallback';
-    }
+    const finalAgentId = route.agentId || 'main';
+    const routingSource = route.agentId ? 'sdk-scoped-route' : 'sdk-default-fallback';
 
     logger.info(`[pier-connector] Routing account '${inbound.accountId}' -> agent '${finalAgentId}' (Source: ${routingSource})`);
 
@@ -109,28 +79,27 @@ export async function handleInbound(
     logger.info(`[pier-connector:trace] Finalized inbound context for job ${jobId}. Target Agent: ${finalAgentId}, Session: ${dynamicSessionKey}`);
 
     const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
-        AgentId: finalAgentId,
-        agentId: finalAgentId, // Redundant for compatibility
         Body: inbound.body,
         BodyForAgent: inbound.body,
         RawBody: inbound.body,
         From: inbound.senderId,
-        To: `pier:${jobId}`,
+        To: `chat:${jobId}`,
         SessionKey: dynamicSessionKey,
         AccountId: inbound.accountId, 
         ChatType: 'direct',
         SenderId: inbound.senderId,
+        SenderName: robot.accountId,
         Provider: 'pier',
         Surface: 'pier',
         OriginatingChannel: 'pier',
-        OriginatingTo: `pier:${jobId}`,
+        OriginatingTo: `chat:${jobId}`,
         WasMentioned: true,
         CommandAuthorized: true,
         SystemPrompt: injectedPrompt,
         MessageId: jobId,
+        MessageSid: jobId,
         Metadata: { 
             ...metadata,
-            agentId: finalAgentId, // Pinning in metadata
             accountId: robot.accountId,
             pierJobId: jobId,
             routingSource: routingSource
@@ -170,7 +139,7 @@ export async function handleInbound(
     try {
         logger.info(`[pier-connector:trace] Dispatching reply to agent ${finalAgentId}...`);
         await api.runtime.channel.reply.dispatchReplyFromConfig({
-            ctx: ctxPayload, cfg: api.config, dispatcher
+            ctx: ctxPayload, cfg: accountScopedCfg, dispatcher
         });
         logger.info(`[pier-connector:trace] dispatchReplyFromConfig completed for job ${jobId}`);
     } catch (err: any) {

package/src/index.ts

@@ -117,8 +117,9 @@ const register = (api: PierPluginApi) => {
             },
             required: ['task']
         },
-        async execute(_id, params) {
-            const robot = instances.get(params.accountId || 'default') || instances.values().next().value;
+        async execute(_id, params, ctx: any) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+            const robot = instances.get(accountId) || instances.values().next().value;
             if (!robot || robot.connectionStatus !== 'connected') {
                 return { 
                     content: [{ type: 'text', text: 'Robot not connected' }],
@@ -150,7 +151,7 @@ const register = (api: PierPluginApi) => {
                 required: ['jobId', 'text']
             },
             async execute(_id, params, ctx: any) {
-                const accountId = params.accountId || 'default';
+                const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
                 const robot = instances.get(accountId) || instances.values().next().value;
                 if (!robot || robot.connectionStatus !== 'connected') {
                     return { content: [{ type: 'text', text: 'Error: Robot not connected' }], details: {} };
@@ -206,8 +207,8 @@ const register = (api: PierPluginApi) => {
                 },
                 required: ['jobId', ...Object.keys(extraParams)]
             },
-            async execute(_id, params) {
-                const accountId = params.accountId || 'default';
+            async execute(_id, params, ctx: any) {
+                const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
                 const robot = instances.get(accountId) || instances.values().next().value;
                 if (!robot || robot.connectionStatus !== 'connected') {
                     return { content: [{ type: 'text', text: 'Error: Robot not connected' }], details: {} };
@@ -265,8 +266,9 @@ const register = (api: PierPluginApi) => {
             type: 'object',
             properties: { accountId: { type: 'string' } }
         },
-        async execute(_id, params) {
-            const robot = instances.get(params.accountId || 'default') || instances.values().next().value;
+        async execute(_id, params, ctx: any) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+            const robot = instances.get(accountId) || instances.values().next().value;
             if (!robot) return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
             try {
                 const profile = await robot.client.getUserProfile(robot.config.secretKey);