adp-openclaw 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
   "dependencies": {

package/src/channel.ts

@@ -12,7 +12,6 @@ export type AdpOpenclawChannelConfig = {
   enabled?: boolean;
   serverUrl?: string;
   wsUrl?: string;
-  apiToken?: string;
   clientToken?: string;
   pollIntervalMs?: number;
 };
@@ -23,13 +22,13 @@ export type ResolvedAdpOpenclawAccount = {
   enabled: boolean;
   configured: boolean;
   serverUrl: string;
-  apiToken: string;
+  clientToken: string;
   pollIntervalMs: number;
 };
 
 function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
   serverUrl: string;
-  apiToken: string;
+  clientToken: string;
   pollIntervalMs: number;
 } | null {
   // Get serverUrl: support both serverUrl and wsUrl
@@ -45,23 +44,20 @@ function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
     serverUrl = process.env.ADP_OPENCLAW_SERVER_URL || "";
   }
 
-  // Get apiToken: support both apiToken and clientToken
-  let apiToken = channelCfg?.apiToken?.trim();
-  if (!apiToken && channelCfg?.clientToken) {
-    apiToken = channelCfg.clientToken.trim();
-  }
-  if (!apiToken) {
-    apiToken = process.env.ADP_OPENCLAW_API_TOKEN || "";
+  // Get clientToken from config or env
+  let clientToken = channelCfg?.clientToken?.trim();
+  if (!clientToken) {
+    clientToken = process.env.ADP_OPENCLAW_CLIENT_TOKEN || "";
   }
 
   // Both are required for configured status
-  if (!serverUrl || !apiToken) {
+  if (!serverUrl || !clientToken) {
     return null;
   }
 
   const pollIntervalMs = channelCfg?.pollIntervalMs ?? 1000;
 
-  return { serverUrl, apiToken, pollIntervalMs };
+  return { serverUrl, clientToken, pollIntervalMs };
 }
 
 function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpenclawAccount {
@@ -75,7 +71,7 @@ function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpe
     enabled,
     configured: Boolean(creds),
     serverUrl: creds?.serverUrl || "http://localhost:9876",
-    apiToken: creds?.apiToken || "",
+    clientToken: creds?.clientToken || "",
     pollIntervalMs: creds?.pollIntervalMs || 1000,
   };
 }
@@ -96,6 +92,11 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
     reactions: false,
     threads: false,
     media: false,
+    /**
+     * blockStreaming: true 启用 SDK 的块流式功能
+     * SDK 会通过 deliver 回调的 info.kind="block" 传递流式块
+     */
+    blockStreaming: true,
   },
   reload: { configPrefixes: ["channels.adp-openclaw"] },
   configSchema: {
@@ -106,7 +107,6 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
         enabled: { type: "boolean" },
         serverUrl: { type: "string" },
         wsUrl: { type: "string" },
-        apiToken: { type: "string" },
         clientToken: { type: "string" },
         pollIntervalMs: { type: "integer", minimum: 100 },
       },
@@ -222,7 +222,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
       const { monitorAdpOpenclaw } = await import("./monitor.js");
       return monitorAdpOpenclaw({
         serverUrl: account.serverUrl,
-        apiToken: account.apiToken,
+        clientToken: account.clientToken,
         pollIntervalMs: account.pollIntervalMs,
         abortSignal: ctx.abortSignal,
         log: ctx.log,
@@ -256,7 +256,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${account.apiToken}`,
+          Authorization: `Bearer ${account.clientToken}`,
         },
         body: JSON.stringify({
           to: target,

package/src/config-schema.ts

@@ -3,6 +3,6 @@ import { z } from "zod";
 export const AdpOpenclawConfigSchema = z.object({
   enabled: z.boolean().optional(),
   serverUrl: z.string().optional(),
-  apiToken: z.string().optional(),
+  clientToken: z.string().optional(),
   pollIntervalMs: z.number().optional(),
 });

package/src/monitor.ts

@@ -7,7 +7,7 @@ import crypto from "crypto";
 
 export type MonitorParams = {
   serverUrl: string;
-  apiToken: string;
+  clientToken: string;
   pollIntervalMs: number; // Used as reconnect delay
   abortSignal?: AbortSignal;
   log?: PluginLogger;
@@ -22,6 +22,8 @@ const MsgType = {
   Pong: "pong",
   Inbound: "inbound",
   Outbound: "outbound",
+  OutboundChunk: "outbound_chunk",
+  OutboundEnd: "outbound_end",
   Ack: "ack",
   Error: "error",
   ConvHistory: "conv_history",
@@ -63,9 +65,10 @@ type AuthResultPayload = {
   message?: string;
 };
 
-// Generate HMAC-SHA256 signature for extra security
-function generateSignature(token: string, nonce: string): string {
-  return crypto.createHash("sha256").update(`${token}:${nonce}`).digest("hex");
+// Generate HMAC-SHA256 signature for authentication (includes timestamp for anti-replay)
+function generateSignature(token: string, nonce: string, timestamp: number): string {
+  // Use HMAC-SHA256 with token as the key, and "nonce:timestamp" as the message
+  return crypto.createHmac("sha256", token).update(`${nonce}:${timestamp}`).digest("hex");
 }
 
 // Generate random nonce
@@ -79,7 +82,7 @@ function generateRequestId(): string {
 }
 
 export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
-  const { serverUrl, apiToken, pollIntervalMs, abortSignal, log, cfg } = params;
+  const { serverUrl, clientToken, pollIntervalMs, abortSignal, log, cfg } = params;
   const runtime = getAdpOpenclawRuntime();
 
   // Convert HTTP URL to WebSocket URL
@@ -91,7 +94,7 @@ export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
     try {
       await connectAndHandle({
         wsUrl,
-        apiToken,
+        clientToken,
         serverUrl,
         abortSignal,
         log,
@@ -115,7 +118,7 @@ export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
 
 type ConnectParams = {
   wsUrl: string;
-  apiToken: string;
+  clientToken: string;
   serverUrl: string;
   abortSignal?: AbortSignal;
   log?: PluginLogger;
@@ -124,7 +127,7 @@ type ConnectParams = {
 };
 
 async function connectAndHandle(params: ConnectParams): Promise<void> {
-  const { wsUrl, apiToken, serverUrl, abortSignal, log, runtime, cfg } = params;
+  const { wsUrl, clientToken, serverUrl, abortSignal, log, runtime, cfg } = params;
 
   // Dynamic import for WebSocket (works in both Node.js and browser)
   const WebSocket = (await import("ws")).default;
@@ -144,19 +147,21 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
     ws.on("open", () => {
       log?.info(`[adp-openclaw] WebSocket connected, authenticating...`);
 
-      // Send authentication message with signature
+      // Send authentication message with signature (includes timestamp for anti-replay)
       const nonce = generateNonce();
-      const signature = generateSignature(apiToken, nonce);
+      const timestamp = Date.now();
+      const signature = generateSignature(clientToken, nonce, timestamp);
 
       const authMsg: WSMessage = {
         type: MsgType.Auth,
         requestId: generateRequestId(),
         payload: {
-          token: apiToken,
+          token: clientToken,
           nonce,
           signature,
+          timestamp, // Include timestamp in payload for server verification
         },
-        timestamp: Date.now(),
+        timestamp,
       };
 
       ws.send(JSON.stringify(authMsg));
@@ -257,29 +262,89 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 ...userMetadata,
               });
 
+              // Generate unique stream ID for this response
+              const streamId = `stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+              let chunkIndex = 0;
+              const displayName = inMsg.user?.username || inMsg.from;
+
               await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                 ctx,
                 cfg: cfg ?? {},
                 dispatcherOptions: {
-                  deliver: async (payload: { text: string }) => {
-                    const displayName = inMsg.user?.username || inMsg.from;
-                    log?.info(`[adp-openclaw] Sending reply to ${displayName}: ${payload.text.slice(0, 50)}...`);
-
-                    // Send via WebSocket
-                    const outMsg: WSMessage = {
-                      type: MsgType.Outbound,
-                      requestId: generateRequestId(),
-                      payload: {
-                        to: inMsg.from,
-                        text: payload.text,
-                        conversationId: inMsg.conversationId,
-                        // Include user info in response for tracing
-                        user: inMsg.user,
-                      },
-                      timestamp: Date.now(),
-                    };
-
-                    ws.send(JSON.stringify(outMsg));
+                  // Unified deliver callback - handles both streaming blocks and final reply
+                  // SDK calls this with info.kind = "block" for streaming chunks, "final" for complete response
+                  deliver: async (payload: { text?: string }, info?: { kind?: string }) => {
+                    const text = payload.text || "";
+                    const kind = info?.kind || "final";
+                    
+                    // Handle streaming block - send chunk via WebSocket
+                    if (kind === "block" && text) {
+                      log?.debug?.(`[adp-openclaw] Streaming block[${chunkIndex}] to ${displayName}: ${text.slice(0, 30)}...`);
+
+                      const chunkMsg: WSMessage = {
+                        type: MsgType.OutboundChunk,
+                        requestId: generateRequestId(),
+                        payload: {
+                          to: inMsg.from,
+                          chunk: text,
+                          conversationId: inMsg.conversationId,
+                          streamId: streamId,
+                          index: chunkIndex,
+                          user: inMsg.user,
+                        },
+                        timestamp: Date.now(),
+                      };
+
+                      ws.send(JSON.stringify(chunkMsg));
+                      chunkIndex++;
+                      return;
+                    }
+
+                    // Handle tool result - log but don't send separately
+                    if (kind === "tool") {
+                      log?.debug?.(`[adp-openclaw] Tool result received for ${displayName}`);
+                      return;
+                    }
+
+                    // Handle final reply
+                    if (kind === "final") {
+                      log?.info(`[adp-openclaw] Sending final reply to ${displayName}: ${text.slice(0, 50)}...`);
+
+                      // If we have streaming chunks, send stream end message
+                      if (chunkIndex > 0) {
+                        const endMsg: WSMessage = {
+                          type: MsgType.OutboundEnd,
+                          requestId: generateRequestId(),
+                          payload: {
+                            to: inMsg.from,
+                            text: text,
+                            conversationId: inMsg.conversationId,
+                            streamId: streamId,
+                            totalChunks: chunkIndex,
+                            user: inMsg.user,
+                          },
+                          timestamp: Date.now(),
+                        };
+
+                        ws.send(JSON.stringify(endMsg));
+                      } else {
+                        // No streaming chunks were sent, send as regular outbound message
+                        const outMsg: WSMessage = {
+                          type: MsgType.Outbound,
+                          requestId: generateRequestId(),
+                          payload: {
+                            to: inMsg.from,
+                            text: text,
+                            conversationId: inMsg.conversationId,
+                            // Include user info in response for tracing
+                            user: inMsg.user,
+                          },
+                          timestamp: Date.now(),
+                        };
+
+                        ws.send(JSON.stringify(outMsg));
+                      }
+                    }
                   },
                   onError: (err: Error) => {
                     log?.error(`[adp-openclaw] Reply error: ${err.message}`);

package/src/runtime.ts

@@ -8,7 +8,6 @@ export type PluginConfig = {
   wsUrl?: string;
   clientToken?: string;
   serverUrl?: string;
-  apiToken?: string;
   pollIntervalMs?: number;
 };