agent-relay 3.1.1 → 3.1.2

package/packages/openclaw/src/gateway.ts

@@ -3,7 +3,15 @@ import { createServer, type Server as HttpServer, type IncomingMessage, type Ser
 
 import type { SendMessageInput } from '@agent-relay/sdk';
 import { RelayCast, type AgentClient } from '@relaycast/sdk';
-import type { MessageCreatedEvent, MessageWithMeta, ThreadReplyEvent } from '@relaycast/sdk';
+import type {
+  MessageCreatedEvent,
+  ThreadReplyEvent,
+  DmReceivedEvent,
+  GroupDmReceivedEvent,
+  CommandInvokedEvent,
+  ReactionAddedEvent,
+  ReactionRemovedEvent,
+} from '@relaycast/sdk';
 import WebSocket from 'ws';
 
 import type { GatewayConfig, InboundMessage, DeliveryResult } from './types.js';
@@ -106,7 +114,8 @@ interface PendingRpc {
   timer: ReturnType<typeof setTimeout>;
 }
 
-class OpenClawGatewayClient {
+/** @internal */
+export class OpenClawGatewayClient {
   private ws: WebSocket | null = null;
   private authenticated = false;
   private device: DeviceIdentity;
@@ -419,15 +428,12 @@ export class InboundGateway {
   private relayAgentClient: AgentClient | null = null;
   private readonly relaycast: RelayCast;
   private readonly config: GatewayConfig;
-  private readonly fallbackPollMs: number;
   private readonly dedupeTtlMs: number;
 
   private running = false;
-  private pollTimer: ReturnType<typeof setInterval> | null = null;
   private unsubscribeHandlers: Array<() => void> = [];
   private seenMessageIds = new Map<string, number>();
   private processingMessageIds = new Set<string>();
-  private channelCursor = new Map<string, string>();
 
   /** Persistent WebSocket client for the local OpenClaw gateway. */
   private openclawClient: OpenClawGatewayClient | null = null;
@@ -453,11 +459,6 @@ export class InboundGateway {
       baseUrl: this.config.baseUrl,
     });
 
-    const fallbackPollMs = Number(process.env.RELAYCAST_FALLBACK_POLL_MS ?? 15000);
-    this.fallbackPollMs = Number.isFinite(fallbackPollMs) && fallbackPollMs >= 1000
-      ? Math.floor(fallbackPollMs)
-      : 15000;
-
     const dedupeTtlMs = Number(process.env.RELAYCAST_DEDUPE_TTL_MS ?? 15 * 60 * 1000);
     this.dedupeTtlMs = Number.isFinite(dedupeTtlMs) && dedupeTtlMs >= 1000
       ? Math.floor(dedupeTtlMs)
@@ -467,7 +468,7 @@ export class InboundGateway {
     this.spawnManager = new SpawnManager({ spawnDepth: parentDepth + 1 });
   }
 
-  /** Start the gateway — register agent, subscribe for realtime events, and run fallback polling. */
+  /** Start the gateway — register agent and subscribe for realtime events. */
   async start(): Promise<void> {
     if (this.running) return;
     this.running = true;
@@ -521,6 +522,36 @@ export class InboundGateway {
         void this.handleRealtimeThreadReply(event);
       }),
     );
+    this.unsubscribeHandlers.push(
+      this.relayAgentClient.on.dmReceived((event: DmReceivedEvent) => {
+        console.log(`[gateway] DM from @${event.message?.agentName} (conv: ${event.conversationId})`);
+        void this.handleRealtimeDm(event);
+      }),
+    );
+    this.unsubscribeHandlers.push(
+      this.relayAgentClient.on.groupDmReceived((event: GroupDmReceivedEvent) => {
+        console.log(`[gateway] Group DM from @${event.message?.agentName} (conv: ${event.conversationId})`);
+        void this.handleRealtimeGroupDm(event);
+      }),
+    );
+    this.unsubscribeHandlers.push(
+      this.relayAgentClient.on.commandInvoked((event: CommandInvokedEvent) => {
+        console.log(`[gateway] Command /${event.command} invoked by @${event.invokedBy} in #${event.channel}`);
+        void this.handleRealtimeCommand(event);
+      }),
+    );
+    this.unsubscribeHandlers.push(
+      this.relayAgentClient.on.reactionAdded((event: ReactionAddedEvent) => {
+        console.log(`[gateway] Reaction :${event.emoji}: added by @${event.agentName} on ${event.messageId}`);
+        void this.handleRealtimeReaction(event, 'added');
+      }),
+    );
+    this.unsubscribeHandlers.push(
+      this.relayAgentClient.on.reactionRemoved((event: ReactionRemovedEvent) => {
+        console.log(`[gateway] Reaction :${event.emoji}: removed by @${event.agentName} from ${event.messageId}`);
+        void this.handleRealtimeReaction(event, 'removed');
+      }),
+    );
     this.unsubscribeHandlers.push(
       this.relayAgentClient.on.reconnecting((attempt: number) => {
         console.warn(`[gateway] Relaycast reconnecting (attempt ${attempt})`);
@@ -547,14 +578,6 @@ export class InboundGateway {
       // Will subscribe on next connected event
     }
 
-    // Initial catch-up in case messages arrived before realtime subscription was active.
-    await this.pollMessages();
-
-    // Keep a low-frequency poll as recovery/backfill only.
-    this.pollTimer = setInterval(() => {
-      void this.pollMessages();
-    }, this.fallbackPollMs);
-
     console.log(
       `[gateway] Realtime listening on channels: ${this.config.channels.join(', ')}`,
     );
@@ -567,11 +590,6 @@ export class InboundGateway {
   async stop(): Promise<void> {
     this.running = false;
 
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-
     for (const unsubscribe of this.unsubscribeHandlers) {
       try {
         unsubscribe();
@@ -603,7 +621,6 @@ export class InboundGateway {
     await this.spawnManager.releaseAll();
 
     this.processingMessageIds.clear();
-    this.channelCursor.clear();
     this.seenMessageIds.clear();
   }
 
@@ -681,40 +698,87 @@ export class InboundGateway {
     await this.handleInbound(inbound);
   }
 
-  private normalizePolledMessage(channel: string, message: MessageWithMeta): InboundMessage {
-    return {
-      id: message.id,
-      channel,
-      from: message.agentName,
-      text: message.text,
-      timestamp: message.createdAt,
+  private async handleRealtimeDm(event: DmReceivedEvent): Promise<void> {
+    const messageId = event.message?.id;
+    if (!messageId) return;
+
+    const inbound: InboundMessage = {
+      id: messageId,
+      channel: 'dm',
+      from: event.message.agentName,
+      text: event.message.text,
+      timestamp: new Date().toISOString(),
+      conversationId: event.conversationId,
+      kind: 'dm',
     };
+
+    await this.handleInbound(inbound);
   }
 
-  /** Poll channels for catch-up/recovery only. */
-  private async pollMessages(): Promise<void> {
-    if (!this.running) return;
+  private async handleRealtimeGroupDm(event: GroupDmReceivedEvent): Promise<void> {
+    const messageId = event.message?.id;
+    if (!messageId) return;
 
-    for (const channel of this.config.channels) {
-      try {
-        const after = this.channelCursor.get(channel);
-        const query: { limit: number; after?: string } = { limit: 50 };
-        if (after) {
-          query.after = after;
-        }
+    const inbound: InboundMessage = {
+      id: messageId,
+      channel: `groupdm:${event.conversationId}`,
+      from: event.message.agentName,
+      text: event.message.text,
+      timestamp: new Date().toISOString(),
+      conversationId: event.conversationId,
+      kind: 'groupdm',
+    };
+
+    await this.handleInbound(inbound);
+  }
 
-        const messages = await this.relaycast.messages.list(channel, query);
-        const ordered = [...messages].sort((a, b) =>
-          a.createdAt.localeCompare(b.createdAt),
-        );
+  private async handleRealtimeCommand(event: CommandInvokedEvent): Promise<void> {
+    const channel = normalizeChannelName(event.channel);
+    if (!this.config.channels.includes(channel)) return;
 
-        for (const message of ordered) {
-          await this.handleInbound(this.normalizePolledMessage(channel, message));
-        }
-      } catch (err) {
-        console.warn(`[gateway] Poll error for #${channel}: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
+    // Commands lack a server-assigned event ID, so we synthesize one.
+    // We include args + timestamp to avoid silently dropping legitimate
+    // repeat invocations (e.g. /deploy twice in 15 min). This means SDK
+    // reconnection replays may deliver a duplicate, but that's less
+    // harmful than silently swallowing a real command.
+    const argsSlug = event.args ? `_${event.args}` : '';
+    const syntheticId = `cmd_${event.command}_${channel}_${event.invokedBy}${argsSlug}_${Date.now()}`;
+    const argsText = event.args ? ` ${event.args}` : '';
+
+    const inbound: InboundMessage = {
+      id: syntheticId,
+      channel,
+      from: event.invokedBy,
+      text: `[relaycast:command:${channel}] @${event.invokedBy} /${event.command}${argsText}`,
+      timestamp: new Date().toISOString(),
+      kind: 'command',
+    };
+
+    await this.handleInbound(inbound);
+  }
+
+  private async handleRealtimeReaction(
+    event: ReactionAddedEvent | ReactionRemovedEvent,
+    action: 'added' | 'removed',
+  ): Promise<void> {
+    // Include timestamp so add→remove→re-add of the same emoji isn't
+    // silently dropped within the 15-min dedup window. Reactions are soft
+    // notifications, so a rare duplicate on SDK reconnect is acceptable.
+    const syntheticId = `reaction_${event.messageId}_${event.emoji}_${event.agentName}_${action}_${Date.now()}`;
+    const text = action === 'added'
+      ? `[relaycast:reaction] @${event.agentName} reacted ${event.emoji} to message ${event.messageId} (soft notification, no action required)`
+      : `[relaycast:reaction] @${event.agentName} removed ${event.emoji} from message ${event.messageId} (soft notification, no action required)`;
+
+    const inbound: InboundMessage = {
+      id: syntheticId,
+      channel: 'reaction',
+      from: event.agentName,
+      text,
+      timestamp: new Date().toISOString(),
+      kind: 'reaction',
+    };
+
+    await this.handleInbound(inbound);
   }
 
   private async handleInbound(message: InboundMessage): Promise<void> {
@@ -724,13 +788,13 @@ export class InboundGateway {
     // Avoid echo loops — skip messages from this claw or its viewer identity.
     const viewerName = `viewer-${this.config.clawName}`;
     if (message.from === this.config.clawName || message.from === viewerName) {
-      this.channelCursor.set(normalizeChannelName(message.channel), message.id);
+      // Only update cursor for real channels with real (non-synthetic) message IDs.
       this.markSeen(message.id);
       return;
     }
 
     // Mark as seen immediately to prevent duplicate delivery from concurrent
-    // realtime + poll paths processing the same message.
+    // realtime events processing the same message.
     this.markSeen(message.id);
     this.processingMessageIds.add(message.id);
 
@@ -738,7 +802,6 @@ export class InboundGateway {
     try {
       const result = await this.onMessage(message);
       console.log(`[gateway] Delivery result: ${result.method} ok=${result.ok}${result.error ? ' error=' + result.error : ''}`);
-      this.channelCursor.set(normalizeChannelName(message.channel), message.id);
     } finally {
       this.processingMessageIds.delete(message.id);
     }
@@ -746,6 +809,16 @@ export class InboundGateway {
 
   /** Format delivery text with channel, sender, and optional thread prefix. */
   private formatDeliveryText(message: InboundMessage): string {
+    // Pre-formatted kinds (command, reaction) already have the full text.
+    if (message.kind === 'command' || message.kind === 'reaction') {
+      return message.text;
+    }
+    if (message.kind === 'dm') {
+      return `[relaycast:dm] @${message.from}: ${message.text}`;
+    }
+    if (message.kind === 'groupdm') {
+      return `[relaycast:groupdm] @${message.from}: ${message.text}`;
+    }
     const threadPrefix = message.threadParentId ? '[thread] ' : '';
     return `${threadPrefix}[relaycast:${message.channel}] @${message.from}: ${message.text}`;
   }

package/packages/openclaw/src/types.ts

@@ -16,7 +16,7 @@ export interface GatewayConfig {
 export interface InboundMessage {
   /** Relaycast message ID. */
   id: string;
-  /** Channel the message was posted to. */
+  /** Channel the message was posted to. Synthetic for DMs (e.g. "dm", "groupdm:{id}"). */
   channel: string;
   /** Agent name of the sender. */
   from: string;
@@ -26,6 +26,10 @@ export interface InboundMessage {
   timestamp: string;
   /** Parent message ID when this is a thread reply. */
   threadParentId?: string;
+  /** Conversation ID for DMs / group DMs. */
+  conversationId?: string;
+  /** Message kind hint for formatting. */
+  kind?: 'channel' | 'thread' | 'dm' | 'groupdm' | 'command' | 'reaction';
 }
 
 export interface DeliveryResult {

package/packages/policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/policy",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Agent policy management with multi-level fallback (repo, local PRPM, cloud workspace)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.1"
+    "@agent-relay/config": "3.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/sdk",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -81,7 +81,7 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.1",
+    "@agent-relay/config": "3.1.2",
     "@relaycast/sdk": "^0.4.0",
     "yaml": "^2.7.0"
   }

package/packages/sdk-py/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-relay-sdk"
-version = "3.1.1"
+version = "3.1.2"
 description = "Python SDK for Agent Relay workflows"
 readme = "README.md"
 license = "Apache-2.0"

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Anonymous telemetry for Agent Relay usage analytics",
   "type": "module",
   "main": "dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/trajectory",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Trajectory integration utilities (trail/PDERO) for Relay",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.1"
+    "@agent-relay/config": "3.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "User directory service for agent-relay (per-user credential storage)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/utils": "3.1.1"
+    "@agent-relay/utils": "3.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/utils",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Shared utilities for agent-relay: logging, name generation, command resolution, update checking",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -112,7 +112,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@agent-relay/config": "3.1.1",
+    "@agent-relay/config": "3.1.2",
     "compare-versions": "^6.1.1"
   },
   "publishConfig": {