adp-openclaw 0.0.69 → 0.0.71

package/package.json

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

package/src/channel.ts

@@ -3,14 +3,28 @@
 
 import {
   type ChannelPlugin,
-  type ClawdbotConfig,
-  DEFAULT_ACCOUNT_ID,
+  type OpenClawConfig,
 } from "openclaw/plugin-sdk";
-import { adpOpenclawOnboardingAdapter } from "./onboarding.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/core";
+import { adpOpenclawSetupWizard } from "./onboarding.js";
 import { getActiveWebSocket } from "./runtime.js";
 
-// Default WebSocket URL for ADP OpenClaw
-const DEFAULT_WS_URL = "wss://wss.lke.cloud.tencent.com/bot/gateway/conn";
+// WebSocket URLs for ADP OpenClaw (domestic vs international)
+const WS_URL_DOMESTIC = "wss://wss.lke.cloud.tencent.com/bot/gateway/conn";
+const WS_URL_INTL = "wss://wss.lke.tencentcloud.com/bot/gateway/conn";
+
+/**
+ * Resolve WebSocket URL based on clientToken prefix.
+ * - Domestic token: sk-adp-{part1}-{part2}  → WS_URL_DOMESTIC
+ * - International token: sk-adp_intl-{part1}-{part2} → WS_URL_INTL
+ * - Fallback: domestic URL
+ */
+function resolveWsUrlFromToken(clientToken?: string): string {
+  if (clientToken?.startsWith("sk-adp_intl-")) {
+    return WS_URL_INTL;
+  }
+  return WS_URL_DOMESTIC;
+}
 
 // Channel-level config type (from channels["adp-openclaw"])
 export type AdpOpenclawChannelConfig = {
@@ -35,33 +49,33 @@ function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
   clientToken: string;
   signKey: string;
 } | null {
-  // Get wsUrl from config or env (has default value)
-  let wsUrl = channelCfg?.wsUrl?.trim();
-  if (!wsUrl) {
-    wsUrl = process.env.ADP_OPENCLAW_WS_URL || DEFAULT_WS_URL;
-  }
-
   // Get clientToken from config or env
   let clientToken = channelCfg?.clientToken?.trim();
   if (!clientToken) {
     clientToken = process.env.ADP_OPENCLAW_CLIENT_TOKEN || "";
   }
 
+  // clientToken is required for configured status
+  if (!clientToken) {
+    return null;
+  }
+
+  // Get wsUrl: explicit config > env var > auto-detect from clientToken prefix
+  let wsUrl = channelCfg?.wsUrl?.trim();
+  if (!wsUrl) {
+    wsUrl = process.env.ADP_OPENCLAW_WS_URL || resolveWsUrlFromToken(clientToken);
+  }
+
   // Get signKey from config or env (default: ADPOpenClaw)
   let signKey = channelCfg?.signKey?.trim();
   if (!signKey) {
     signKey = process.env.ADP_OPENCLAW_SIGN_KEY || "ADPOpenClaw";
   }
 
-  // clientToken is required for configured status (wsUrl has default)
-  if (!clientToken) {
-    return null;
-  }
-
   return { wsUrl, clientToken, signKey };
 }
 
-function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpenclawAccount {
+function resolveAccount(cfg: OpenClawConfig, accountId?: string): ResolvedAdpOpenclawAccount {
   const channelCfg = cfg.channels?.["adp-openclaw"] as AdpOpenclawChannelConfig | undefined;
   const enabled = channelCfg?.enabled !== false;
   const creds = resolveAdpOpenclawCredentials(channelCfg);
@@ -71,7 +85,7 @@ function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpe
     name: "ADP OpenClaw",
     enabled,
     configured: Boolean(creds),
-    wsUrl: creds?.wsUrl || DEFAULT_WS_URL,
+    wsUrl: creds?.wsUrl || resolveWsUrlFromToken(creds?.clientToken),
     clientToken: creds?.clientToken || "",
     signKey: creds?.signKey || "ADPOpenClaw",
   };
@@ -87,7 +101,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
     blurb: "ADP channel backed by a Go WebSocket server.",
     order: 999,
   },
-  onboarding: adpOpenclawOnboardingAdapter,
+  setupWizard: adpOpenclawSetupWizard,
   capabilities: {
     chatTypes: ["direct"],
     polls: false,
@@ -107,7 +121,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
       additionalProperties: false,
       properties: {
         enabled: { type: "boolean" },
-        wsUrl: { type: "string" }, // WebSocket URL (optional, default: wss://wss.lke.cloud.tencent.com/bot/gateway/conn)
+        wsUrl: { type: "string" }, // WebSocket URL (optional, auto-detected from clientToken prefix)
         clientToken: { type: "string" },
         signKey: { type: "string" },
       },
@@ -128,7 +142,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
       },
     }),
     deleteAccount: ({ cfg }) => {
-      const next = { ...cfg } as ClawdbotConfig;
+      const next = { ...cfg } as OpenClawConfig;
       const nextChannels = { ...cfg.channels };
       delete (nextChannels as Record<string, unknown>)["adp-openclaw"];
       if (Object.keys(nextChannels).length > 0) {

package/src/config-schema.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 
 export const AdpOpenclawConfigSchema = z.object({
   enabled: z.boolean().optional(),
-  wsUrl: z.string().optional(), // WebSocket URL (optional, default: wss://wss.lke.cloud.tencent.com/bot/gateway/conn)
+  wsUrl: z.string().optional(), // WebSocket URL (optional, auto-detected from clientToken prefix: sk-adp- → domestic, sk-adp_intl- → international)
   clientToken: z.string().optional(),
   signKey: z.string().optional(),
 });

package/src/monitor.ts

@@ -1,7 +1,7 @@
 // Monitor: WebSocket connection to Go server for real-time message handling
 // Supports: API Token auth, conversation tracking for multi-turn dialogues
 
-import type { PluginLogger, ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { PluginLogger, OpenClawConfig } from "openclaw/plugin-sdk";
 import { getAdpOpenclawRuntime, setActiveWebSocket } from "./runtime.js";
 import {
   getChatHistory,
@@ -40,7 +40,7 @@ export type MonitorParams = {
   signKey?: string; // HMAC key for signature generation
   abortSignal?: AbortSignal;
   log?: PluginLogger;
-  cfg?: ClawdbotConfig; // OpenClaw config for model settings
+  cfg?: OpenClawConfig; // OpenClaw config for model settings
   setStatus?: (next: Record<string, unknown>) => void; // SDK health-monitor status reporter
 };
 
@@ -127,7 +127,7 @@ function generateRequestId(): string {
 async function markSessionAborted(params: {
   sessionKey: string;
   runtime: ReturnType<typeof getAdpOpenclawRuntime>;
-  cfg?: ClawdbotConfig;
+  cfg?: OpenClawConfig;
   log?: PluginLogger;
 }): Promise<void> {
   const { sessionKey, runtime, cfg, log } = params;
@@ -206,7 +206,7 @@ type ConnectParams = {
   abortSignal?: AbortSignal;
   log?: PluginLogger;
   runtime: ReturnType<typeof getAdpOpenclawRuntime>;
-  cfg?: ClawdbotConfig;
+  cfg?: OpenClawConfig;
   setStatus?: (next: Record<string, unknown>) => void;
 };
 

package/src/onboarding.ts

@@ -1,10 +1,9 @@
-// Onboarding adapter for ADP OpenClaw channel plugin
+// Setup wizard adapter for ADP OpenClaw channel plugin
+// Migrated from ChannelOnboardingAdapter to ChannelSetupWizard for openclaw >= 2026.3.22
 import type {
-  ChannelOnboardingAdapter,
+  ChannelSetupWizard,
   OpenClawConfig,
-  WizardPrompter,
 } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
 
 const channel = "adp-openclaw" as const;
 
@@ -42,81 +41,89 @@ function updateAdpOpenclawConfig(
   };
 }
 
-async function noteAdpOpenclawSetup(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "ADP OpenClaw connects to a WebSocket server for real-time messaging.",
-      "You need a clientToken to authenticate with the server.",
-      "The signKey is used for HMAC signature generation (default: ADPOpenClaw).",
-    ].join("\n"),
-    "ADP OpenClaw setup",
-  );
-}
-
-export const adpOpenclawOnboardingAdapter: ChannelOnboardingAdapter = {
+export const adpOpenclawSetupWizard: ChannelSetupWizard = {
   channel,
-  getStatus: async ({ cfg }) => {
-    const channelCfg = getChannelConfig(cfg);
-    const configured = isConfigured(channelCfg);
 
-    return {
-      channel,
-      configured,
-      statusLines: [`ADP OpenClaw: ${configured ? "configured" : "needs clientToken"}`],
-      selectionHint: configured ? "configured" : "requires clientToken",
-      quickstartScore: configured ? 1 : 10,
-    };
+  status: {
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs clientToken",
+    configuredHint: "configured",
+    unconfiguredHint: "requires clientToken",
+    configuredScore: 1,
+    unconfiguredScore: 10,
+    resolveConfigured: ({ cfg }) => {
+      const channelCfg = getChannelConfig(cfg);
+      return isConfigured(channelCfg);
+    },
+    resolveStatusLines: ({ cfg, configured }) => {
+      return [`ADP OpenClaw: ${configured ? "configured" : "needs clientToken"}`];
+    },
   },
-  configure: async ({ cfg, prompter }) => {
-    let next = cfg;
-    const accountId = DEFAULT_ACCOUNT_ID;
-
-    await noteAdpOpenclawSetup(prompter);
 
-    const channelCfg = getChannelConfig(next);
-    const existingClientToken = channelCfg?.clientToken?.trim();
-    const existingSignKey = channelCfg?.signKey?.trim();
-
-    // Check for env vars
-    const envClientToken = process.env.ADP_OPENCLAW_CLIENT_TOKEN?.trim();
-    const envSignKey = process.env.ADP_OPENCLAW_SIGN_KEY?.trim();
+  introNote: {
+    title: "ADP OpenClaw setup",
+    lines: [
+      "ADP OpenClaw connects to a WebSocket server for real-time messaging.",
+      "You need a clientToken to authenticate with the server.",
+      "The signKey is used for HMAC signature generation (default: ADPOpenClaw).",
+    ],
+  },
 
-    if (envClientToken) {
-      const useEnv = await prompter.confirm({
-        message: "ADP_OPENCLAW_CLIENT_TOKEN detected in env. Use environment variables?",
-        initialValue: true,
-      });
-      if (useEnv) {
-        next = updateAdpOpenclawConfig(next, { enabled: true });
-        return { cfg: next, accountId };
-      }
-    }
+  envShortcut: {
+    prompt: "ADP_OPENCLAW_CLIENT_TOKEN detected in env. Use environment variables?",
+    preferredEnvVar: "ADP_OPENCLAW_CLIENT_TOKEN",
+    isAvailable: () => Boolean(process.env.ADP_OPENCLAW_CLIENT_TOKEN?.trim()),
+    apply: ({ cfg }) => updateAdpOpenclawConfig(cfg, { enabled: true }),
+  },
 
-    // Prompt for clientToken (required)
-    const clientTokenInput = await prompter.text({
-      message: "Client Token",
-      placeholder: "your-client-token",
-      initialValue: existingClientToken || undefined,
-      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-    });
-    const clientToken = String(clientTokenInput).trim();
+  credentials: [
+    {
+      inputKey: "token",
+      providerHint: "ADP OpenClaw",
+      credentialLabel: "Client Token",
+      preferredEnvVar: "ADP_OPENCLAW_CLIENT_TOKEN",
+      envPrompt: "ADP_OPENCLAW_CLIENT_TOKEN detected. Use it?",
+      keepPrompt: "Client Token already set. Keep it?",
+      inputPrompt: "Client Token",
+      inspect: ({ cfg }) => {
+        const channelCfg = getChannelConfig(cfg);
+        const configuredValue = channelCfg?.clientToken?.trim();
+        const envValue = process.env.ADP_OPENCLAW_CLIENT_TOKEN?.trim();
+        return {
+          accountConfigured: Boolean(configuredValue || envValue),
+          hasConfiguredValue: Boolean(configuredValue),
+          resolvedValue: configuredValue || envValue,
+          envValue,
+        };
+      },
+      applySet: ({ cfg, resolvedValue }) => {
+        return updateAdpOpenclawConfig(cfg, { clientToken: resolvedValue, enabled: true });
+      },
+      applyUseEnv: ({ cfg }) => {
+        return updateAdpOpenclawConfig(cfg, { enabled: true });
+      },
+    },
+  ],
 
-    // Prompt for signKey (optional, has default)
-    const signKeyInput = await prompter.text({
+  textInputs: [
+    {
+      inputKey: "name",
       message: "Sign Key (press Enter for default: ADPOpenClaw)",
       placeholder: "ADPOpenClaw",
-      initialValue: existingSignKey || envSignKey || undefined,
-    });
-    const signKey = String(signKeyInput ?? "").trim() || undefined;
-
-    next = updateAdpOpenclawConfig(next, {
-      clientToken,
-      ...(signKey ? { signKey } : {}),
-      enabled: true,
-    });
+      required: false,
+      currentValue: ({ cfg }) => {
+        const channelCfg = getChannelConfig(cfg);
+        return channelCfg?.signKey?.trim() || process.env.ADP_OPENCLAW_SIGN_KEY?.trim();
+      },
+      applySet: ({ cfg, value }) => {
+        return updateAdpOpenclawConfig(cfg, {
+          ...(value ? { signKey: value } : {}),
+          enabled: true,
+        });
+      },
+    },
+  ],
 
-    return { cfg: next, accountId };
-  },
   disable: (cfg) => {
     return {
       ...cfg,

package/src/session-history.ts

@@ -191,20 +191,46 @@ function resolveSessionTranscriptCandidates(
   return candidates;
 }
 
+/**
+ * Sanitize string to ensure it's valid for JSON serialization.
+ * Removes or replaces characters that could cause JSON parsing issues.
+ */
+function sanitizeForJson(str: string): string {
+  if (!str) return str;
+  
+  let result = str;
+  
+  // Remove EXTERNAL_UNTRUSTED_CONTENT blocks which often contain binary garbage (e.g., images as text)
+  // These blocks are from web_fetch and contain external webpage content that may have encoding issues
+  result = result.replace(
+    /<<<EXTERNAL_UNTRUSTED_CONTENT>>>[\s\S]*?<<<\/EXTERNAL_UNTRUSTED_CONTENT>>>/g,
+    "[External content removed]"
+  );
+  
+  // Remove null characters and other control characters (except common whitespace)
+  // Control characters: 0x00-0x1F (except 0x09 tab, 0x0A newline, 0x0D carriage return)
+  // Also remove 0x7F (DEL) and other problematic chars
+  result = result.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  
+  return result;
+}
+
 /**
  * Extract text content from message content (handles both string and array formats)
  */
 function extractMessageContent(content: string | Array<{ type: string; text?: string }>): string {
+  let text: string;
   if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content
       .filter((part) => part.type === "text" && part.text)
       .map((part) => part.text)
       .join("\n");
+  } else {
+    text = String(content);
   }
-  return String(content);
+  return sanitizeForJson(text);
 }
 
 /**
@@ -857,27 +883,55 @@ export async function getOpenClawChatHistoryViaCli(
     );
     
     // Parse JSON result
+    // OpenClaw CLI returns messages with content that can be:
+    // - string: plain text content
+    // - array: mixed content parts including text, toolCall, etc.
+    // Timestamp can be either number (ms) or ISO string
     const parsed = JSON.parse(result) as {
       messages?: Array<{
         role: string;
-        content: string | Array<{ type: string; text?: string }>;
+        content: string | Array<{ type: string; text?: string; [key: string]: unknown }>;
         id?: string;
-        timestamp?: string;
+        timestamp?: string | number;
       }>;
       sessionId?: string;  // OpenClaw may return the current sessionId
     };
     
-    let messages: OpenClawMessage[] = (parsed.messages ?? []).map((msg) => ({
-      role: msg.role as "user" | "assistant" | "system",
-      content: typeof msg.content === "string"
-        ? msg.content
-        : msg.content
-            .filter((p) => p.type === "text" && p.text)
-            .map((p) => p.text)
-            .join("\n"),
-      id: msg.id,
-      timestamp: msg.timestamp ? new Date(msg.timestamp).getTime() : undefined,
-    }));
+    let messages: OpenClawMessage[] = (parsed.messages ?? []).map((msg) => {
+      // Extract text content from message
+      let textContent: string;
+      if (typeof msg.content === "string") {
+        textContent = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        // Filter for text parts only (skip toolCall, toolResult, etc.)
+        textContent = msg.content
+          .filter((p): p is { type: string; text: string } => 
+            p.type === "text" && typeof p.text === "string"
+          )
+          .map((p) => p.text)
+          .join("\n");
+      } else {
+        textContent = String(msg.content ?? "");
+      }
+      
+      // Sanitize content to remove invalid characters that break JSON serialization
+      textContent = sanitizeForJson(textContent);
+      
+      // Handle timestamp: can be number (ms) or ISO string
+      let timestamp: number | undefined;
+      if (typeof msg.timestamp === "number") {
+        timestamp = msg.timestamp;
+      } else if (typeof msg.timestamp === "string") {
+        timestamp = new Date(msg.timestamp).getTime();
+      }
+      
+      return {
+        role: msg.role as "user" | "assistant" | "system",
+        content: textContent,
+        id: msg.id,
+        timestamp,
+      };
+    });
     
     log?.info?.(`[session-history] Got ${messages.length} messages via CLI`);