@newbase-clawchat/openclaw-clawchat 2026.4.24 → 2026.4.30

package/dist/src/channel.js

@@ -0,0 +1,191 @@
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createChatChannelPlugin, } from "openclaw/plugin-sdk/core";
+import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk/status-helpers";
+import { CHANNEL_ID, listOpenclawClawlingAccountIds, mergeOpenclawClawchatToolAllow, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
+import { openclawClawlingOutbound } from "./outbound.js";
+import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
+const configAdapter = createTopLevelChannelConfigAdapter({
+    sectionKey: CHANNEL_ID,
+    resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
+    listAccountIds: () => listOpenclawClawlingAccountIds(),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    deleteMode: "clear-fields",
+    clearBaseFields: [
+        "websocketUrl",
+        "baseUrl",
+        "token",
+        "userId",
+        "replyMode",
+        "forwardThinking",
+        "forwardToolCalls",
+        "richInteractions",
+        "enabled",
+    ],
+    resolveAllowFrom: (account) => account.allowFrom,
+    formatAllowFrom: () => [],
+});
+/**
+ * Invite-code setup adapter used by OpenClaw setup surfaces that already have
+ * a concrete plugin instance. This plugin does not advertise catalog-driven
+ * one-shot setup metadata because current hosts do not discover channels from
+ * `plugins.load.paths`.
+ *
+ * Setup takes exactly ONE input: `code` (an invite code). URL + token +
+ * userId come from the login flow which is triggered automatically in
+ * `afterAccountConfigWritten`.
+ *
+ * `applyAccountConfig` itself only marks the section `enabled: true`;
+ * credentials are written by `runOpenclawClawlingLogin` via the runtime config
+ * mutator after the `/v1/agents/connect` response lands.
+ */
+const setupAdapter = {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    validateInput: ({ input }) => {
+        if (!input.code?.trim()) {
+            return "ClawChat invite code is required.";
+        }
+        return null;
+    },
+    applyAccountConfig: ({ cfg, }) => {
+        // Base config: just enable the channel. Credentials arrive via
+        // `afterAccountConfigWritten` → `runOpenclawClawlingLogin`.
+        const channels = (cfg.channels ?? {});
+        const current = (channels[CHANNEL_ID] ?? {});
+        return mergeOpenclawClawchatToolAllow({
+            ...cfg,
+            channels: {
+                ...channels,
+                [CHANNEL_ID]: { ...current, enabled: true },
+            },
+        });
+    },
+    afterAccountConfigWritten: async ({ cfg, input, runtime, }) => {
+        const code = input.code?.trim();
+        if (!code)
+            return;
+        // Lazy-import the login runtime to keep @clack/prompts / readline /
+        // config-runtime off the plugin's cold-start path. `readInviteCode`
+        // feeds the fixed code so the stdin prompt is skipped entirely.
+        const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+        await runOpenclawClawlingLogin({
+            cfg,
+            accountId: null,
+            runtime: { log: (message) => runtime.log(message) },
+            readInviteCode: async () => code,
+            mutateConfigFile: getOpenclawClawlingRuntime().config.mutateConfigFile,
+        });
+    },
+};
+export const openclawClawlingPlugin = createChatChannelPlugin({
+    base: {
+        id: CHANNEL_ID,
+        meta: {
+            id: CHANNEL_ID,
+            label: "Clawling Chat",
+            selectionLabel: "Clawling Chat",
+            docsPath: "/channels/openclaw-clawchat",
+            docsLabel: "openclaw-clawchat",
+            blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
+            order: 110,
+        },
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            media: true,
+            reactions: false,
+            threads: false,
+            polls: false,
+            blockStreaming: true,
+        },
+        reload: {
+            configPrefixes: [`channels.${CHANNEL_ID}`],
+        },
+        configSchema: {
+            schema: openclawClawlingConfigSchema,
+        },
+        config: {
+            ...configAdapter,
+            isConfigured: (account) => account.configured,
+            describeAccount: (account) => ({
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured: account.configured,
+            }),
+        },
+        directory: createEmptyChannelDirectoryAdapter(),
+        setup: setupAdapter,
+        status: createComputedAccountStatusAdapter({
+            defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+                connected: false,
+                lastInboundAt: null,
+                lastOutboundAt: null,
+            }),
+            resolveAccountSnapshot: ({ account }) => ({
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured: account.configured,
+                extra: {
+                    websocketUrl: account.websocketUrl || null,
+                    baseUrl: account.baseUrl || null,
+                    userId: account.userId || null,
+                },
+            }),
+        }),
+        auth: {
+            login: async ({ cfg, accountId, runtime }) => {
+                // Lazy-load login.runtime: it pulls in @clack/prompts and other
+                // heavy modules that have no business loading on every plugin
+                // boot. Only the rare `openclaw channels login --channel
+                // openclaw-clawchat` invocation pays the import cost.
+                const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+                await runOpenclawClawlingLogin({
+                    cfg,
+                    accountId: accountId ?? null,
+                    runtime: { log: (message) => runtime.log(message) },
+                    mutateConfigFile: getOpenclawClawlingRuntime().config.mutateConfigFile,
+                });
+            },
+        },
+        gateway: {
+            startAccount: async (ctx) => {
+                const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+                if (!account.configured) {
+                    throw new Error("Clawling Chat websocketUrl/token/userId are required");
+                }
+                return await startOpenclawClawlingGateway({
+                    cfg: ctx.cfg,
+                    account,
+                    abortSignal: ctx.abortSignal,
+                    setStatus: ctx.setStatus,
+                    getStatus: ctx.getStatus,
+                    log: ctx.log,
+                });
+            },
+        },
+        agentPrompt: {
+            messageToolHints: () => [
+                "To send an image or file to the current chat, use the message tool with action='send' and set 'media' to a local file path or a remote URL.",
+                "When the user asks you to find an image from the web, find a suitable HTTPS image URL and send it using the message tool with 'media' set to that URL — do NOT download the image first.",
+                "For configured ClawChat account profile, user profile, friends, avatar, or standalone media upload/share-link workflows, use `clawchat-account-tools` for tool-selection details.",
+                "For ClawChat account avatar changes using a local image, call `clawchat_upload_avatar_image` first, then `clawchat_update_account_profile` with `avatar_url`.",
+                "- Targeting: omit `target` to reply here; for a different chat use `target=\"cc:{chat_id}\"` for direct or `target=\"cc:group:{chat_id}\"` for group.",
+                "- ClawChat supports image / file / audio / video media alongside text.",
+            ],
+        },
+        messaging: {
+            normalizeTarget: (target) => target
+                .trim()
+                .replace(/^openclaw-clawchat:/i, "")
+                .replace(/^clawchat:/i, "")
+                .replace(/^cc:/i, ""),
+            targetResolver: {
+                looksLikeId: (raw, normalized) => Boolean((normalized ?? raw).trim()),
+                hint: "active-session",
+            },
+        },
+    },
+    outbound: openclawClawlingOutbound,
+});

package/dist/src/client.js

@@ -0,0 +1,176 @@
+import { createWSClient, } from "@newbase-clawchat/sdk";
+export function createOpenclawClawlingClient(account, overrides = {}) {
+    // Only forward a finite `maxRetries` to the SDK — the SDK's own default
+    // is already unbounded, so omitting the field keeps that behavior. This
+    // avoids forcing the SDK to special-case `Infinity`.
+    const maxRetries = account.reconnect.maxRetries;
+    const reconnect = {
+        enabled: true,
+        initialDelay: account.reconnect.initialDelay,
+        maxDelay: account.reconnect.maxDelay,
+        jitterRatio: account.reconnect.jitterRatio,
+        ...(Number.isFinite(maxRetries) ? { maxRetries } : {}),
+    };
+    const options = {
+        url: account.websocketUrl,
+        token: account.token,
+        reconnect,
+        heartbeat: {
+            enabled: true,
+            interval: account.heartbeat.interval,
+            timeout: account.heartbeat.timeout,
+        },
+        ack: {
+            timeout: account.ack.timeout,
+            autoResendOnTimeout: account.ack.autoResendOnTimeout,
+        },
+        // Buffer outbound sends during the tiny reconnect window so an inbound
+        // message isn't silently dropped while the socket is flapping.
+        queueWhileReconnecting: true,
+        ...(overrides.transport ? { transport: overrides.transport } : {}),
+        ...(overrides.logger ? { logger: overrides.logger } : {}),
+    };
+    return createWSClient(options);
+}
+function normalizeRouting(params) {
+    if (params.routing)
+        return params.routing;
+    if (params.to?.id) {
+        return { chatId: params.to.id, chatType: params.to.type ?? "direct" };
+    }
+    throw new Error("openclaw-clawchat streaming emit requires routing");
+}
+/**
+ * Emit a raw v2 envelope directly over the transport so we can carry top-level
+ * `chat_id` routing without SDK-injected `to` metadata.
+ */
+function emitEnvelope(client, event, payload, routing) {
+    const inner = client;
+    if (!inner.opts?.transport) {
+        inner.emitRaw?.(event, payload, { to: { id: routing.chatId, type: routing.chatType } });
+        return;
+    }
+    const env = {
+        version: "2",
+        event,
+        trace_id: inner.opts.traceIdFactory(),
+        emitted_at: Date.now(),
+        chat_id: routing.chatId,
+        payload,
+    };
+    inner.opts.transport.send(JSON.stringify(env));
+}
+/**
+ * Emit a minimal `message.created` envelope to open a streaming message.
+ *
+ * Payload is intentionally just `{ message_id }`: the message body, context,
+ * sender, and streaming metadata are not transmitted here — they live on the
+ * envelope (`chat_id`, `chat_type`, optional `sender`) and on the subsequent
+ * `message.add` / `message.done` frames.
+ */
+export function emitStreamCreated(client, params) {
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.created", { message_id: params.messageId }, routing);
+}
+/**
+ * Emit a `message.add` frame with a `fragments` array carrying both the
+ * delta (newly appended text) and the full running text ("from the start
+ * up to now"). Clients rendering the stream can use `delta` for animations
+ * and `text` for the current snapshot.
+ *
+ * Shape: `fragments: [{ kind: "text", text: <cumulative>, delta: <new> }]`
+ */
+export function emitStreamAdd(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.add", {
+        message_id: params.messageId,
+        sequence: params.sequence,
+        mutation: { type: "append", target_fragment_index: null },
+        fragments: [
+            { kind: "text", text: params.fullText, delta: params.textDelta },
+        ],
+        streaming: {
+            status: "streaming",
+            sequence: params.sequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: null,
+        },
+        added_at: now,
+    }, routing);
+}
+/**
+ * Emit a `message.done` frame with the final merged text included as a
+ * single-element `fragments` array so clients can settle the streamed
+ * message on the full text without re-accumulating deltas.
+ */
+export function emitStreamDone(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.done", {
+        message_id: params.messageId,
+        fragments: [{ kind: "text", text: params.finalText }],
+        streaming: {
+            status: "done",
+            sequence: params.finalSequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: now,
+        },
+        completed_at: now,
+    }, routing);
+}
+/**
+ * Emit a `message.reply` envelope that finalizes a streamed reply, carrying
+ * the same `payload.message_id` as the preceding `message.created` /
+ * `message.add` / `message.done` frames.
+ *
+ * The SDK's high-level `client.replyMessage()` disallows `payload.message_id`
+ * on outbound replies (the server normally assigns one via ack); for the
+ * streaming-finalize use case the backend expects the correlated id, so we
+ * bypass the SDK validator and write directly to the transport.
+ */
+export function emitFinalStreamReply(client, params) {
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.reply", {
+        message_id: params.messageId,
+        message_mode: "normal",
+        message: {
+            body: params.body,
+            context: {
+                mentions: params.mentions ?? [],
+                reply: {
+                    reply_to_msg_id: params.replyTo.msgId,
+                    reply_preview: {
+                        id: params.replyTo.previewId,
+                        nick_name: params.replyTo.nickName,
+                        fragments: params.replyTo.fragments,
+                    },
+                },
+            },
+        },
+    }, routing);
+}
+export function emitStreamFailed(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    const reason = params.reason ?? "unknown";
+    const reasonFragment = params.reason?.trim()
+        ? { fragments: [{ kind: "text", text: params.reason.trim() }] }
+        : {};
+    emitEnvelope(client, "message.failed", {
+        message_id: params.messageId,
+        sequence: params.sequence,
+        reason,
+        ...reasonFragment,
+        streaming: {
+            status: "failed",
+            sequence: params.sequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: now,
+        },
+        completed_at: now,
+    }, routing);
+}

package/dist/src/commands.js

@@ -0,0 +1,35 @@
+function extractInviteCode(value) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function registerOpenclawClawlingCommands(api) {
+    api.registerCommand({
+        name: "clawchat-login",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-login A1B2C3.",
+        acceptsArgs: true,
+        requireAuth: true,
+        async handler(ctx) {
+            const code = extractInviteCode(ctx.args ?? ctx.commandBody);
+            if (!code) {
+                return { text: "ClawChat invite code is required. Usage: /clawchat-login A1B2C3" };
+            }
+            try {
+                const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+                await runOpenclawClawlingLogin({
+                    cfg: ctx.config,
+                    accountId: ctx.accountId ?? null,
+                    runtime: { log: (message) => api.logger?.info?.(message) },
+                    readInviteCode: async () => code,
+                    mutateConfigFile: api.runtime.config.mutateConfigFile,
+                });
+                return { text: "✅ ClawChat activated successfully." };
+            }
+            catch (err) {
+                return { text: `❌ ${errorMessage(err)}` };
+            }
+        },
+    });
+}

package/dist/src/config.js

@@ -0,0 +1,214 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+export const CHANNEL_ID = "openclaw-clawchat";
+/**
+ * Built-in defaults for the Clawling Chat endpoints so `openclaw channel
+ * login` works out of the box without requiring a prior `openclaw channel
+ * setup` call. Operators can still override either one via config.
+ *
+ */
+export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086";
+export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws";
+export const DEFAULT_STREAM = {
+    flushIntervalMs: 250,
+    minChunkChars: 40,
+    maxBufferChars: 2000,
+};
+export const DEFAULT_RECONNECT = {
+    // Snappier first retry on transient drops (vs. 1_000).
+    initialDelay: 500,
+    // Cap exponential backoff at 15s — a background gateway reconnecting
+    // every 30s feels unresponsive; 15s is the common IM chat bar.
+    maxDelay: 15_000,
+    // Standard jitter ratio to avoid thundering herd on server restart.
+    jitterRatio: 0.3,
+    // Never give up — the gateway is a long-lived background process.
+    maxRetries: Number.POSITIVE_INFINITY,
+};
+export const DEFAULT_HEARTBEAT = {
+    // 20s keeps NAT/firewall state warm without wasting bandwidth.
+    interval: 20_000,
+    // Pong must arrive within 10s or we tear down and reconnect.
+    timeout: 10_000,
+};
+export const DEFAULT_ACK = {
+    // 15s tolerates a slow server + one retry without false timeouts.
+    timeout: 15_000,
+    // Keep false: auto-resend on timeout risks duplicate messages; the
+    // reconnect path re-queues via `queueWhileReconnecting` instead.
+    autoResendOnTimeout: false,
+};
+export const openclawClawlingConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        websocketUrl: { type: "string" },
+        baseUrl: { type: "string" },
+        token: { type: "string" },
+        refreshToken: { type: "string" },
+        userId: { type: "string" },
+        replyMode: { type: "string", enum: ["static", "stream"] },
+        groupMode: { type: "string", enum: ["mention", "all"] },
+        forwardThinking: { type: "boolean" },
+        forwardToolCalls: { type: "boolean" },
+        richInteractions: { type: "boolean" },
+        stream: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                flushIntervalMs: { type: "integer", minimum: 10 },
+                minChunkChars: { type: "integer", minimum: 1 },
+                maxBufferChars: { type: "integer", minimum: 1 },
+            },
+        },
+        reconnect: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                initialDelay: { type: "integer", minimum: 100 },
+                maxDelay: { type: "integer", minimum: 100 },
+                jitterRatio: { type: "number", minimum: 0 },
+                maxRetries: { type: "integer", minimum: 0 },
+            },
+        },
+        heartbeat: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                interval: { type: "integer", minimum: 1000 },
+                timeout: { type: "integer", minimum: 1000 },
+            },
+        },
+        ack: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                timeout: { type: "integer", minimum: 100 },
+                autoResendOnTimeout: { type: "boolean" },
+            },
+        },
+    },
+};
+function isOpenclawClawchatToolAllowEntry(entry) {
+    return entry === CHANNEL_ID || entry === "group:plugins";
+}
+function hasOpenclawClawchatToolAllow(cfg) {
+    const currentTools = (cfg.tools ?? {});
+    const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
+    const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
+    return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
+}
+function mergeToolPolicyEntryAllow(cfg, entry, isAlreadyCovered) {
+    const currentTools = (cfg.tools ?? {});
+    const currentAlsoAllow = Array.isArray(currentTools.alsoAllow)
+        ? currentTools.alsoAllow.slice()
+        : [];
+    const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow.slice() : [];
+    const alreadyAllowed = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
+    if (currentAllow.length > 0) {
+        return {
+            ...cfg,
+            tools: {
+                ...currentTools,
+                allow: alreadyAllowed ? currentAllow : [...currentAllow, entry],
+            },
+        };
+    }
+    const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
+    return {
+        ...cfg,
+        tools: {
+            ...currentTools,
+            alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+        },
+    };
+}
+export function mergeOpenclawClawchatToolAllow(cfg) {
+    return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+function readChannelSection(cfg) {
+    const channels = (cfg.channels ?? {});
+    const channel = channels[CHANNEL_ID];
+    return channel && typeof channel === "object" ? channel : {};
+}
+function readOptionalString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function readReplyMode(value) {
+    return value === "stream" ? "stream" : "static";
+}
+function readGroupMode(value) {
+    return value === "all" ? "all" : "mention";
+}
+function readStream(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        flushIntervalMs: typeof s.flushIntervalMs === "number" ? s.flushIntervalMs : DEFAULT_STREAM.flushIntervalMs,
+        minChunkChars: typeof s.minChunkChars === "number" ? s.minChunkChars : DEFAULT_STREAM.minChunkChars,
+        maxBufferChars: typeof s.maxBufferChars === "number" ? s.maxBufferChars : DEFAULT_STREAM.maxBufferChars,
+    };
+}
+function readReconnect(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        initialDelay: typeof s.initialDelay === "number" ? s.initialDelay : DEFAULT_RECONNECT.initialDelay,
+        maxDelay: typeof s.maxDelay === "number" ? s.maxDelay : DEFAULT_RECONNECT.maxDelay,
+        jitterRatio: typeof s.jitterRatio === "number" ? s.jitterRatio : DEFAULT_RECONNECT.jitterRatio,
+        maxRetries: typeof s.maxRetries === "number" && Number.isFinite(s.maxRetries)
+            ? s.maxRetries
+            : DEFAULT_RECONNECT.maxRetries,
+    };
+}
+function readHeartbeat(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        interval: typeof s.interval === "number" ? s.interval : DEFAULT_HEARTBEAT.interval,
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_HEARTBEAT.timeout,
+    };
+}
+function readAck(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_ACK.timeout,
+        autoResendOnTimeout: typeof s.autoResendOnTimeout === "boolean"
+            ? s.autoResendOnTimeout
+            : DEFAULT_ACK.autoResendOnTimeout,
+    };
+}
+export function resolveOpenclawClawlingAccount(cfg) {
+    const channel = readChannelSection(cfg);
+    // Apply built-in defaults so login/gateway work without prior setup.
+    const websocketUrl = readOptionalString(channel.websocketUrl) || DEFAULT_WEBSOCKET_URL;
+    const baseUrl = readOptionalString(channel.baseUrl) || DEFAULT_BASE_URL;
+    const token = readOptionalString(channel.token);
+    const userId = readOptionalString(channel.userId);
+    const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
+    const replyMode = readReplyMode(channel.replyMode);
+    const groupMode = readGroupMode(channel.groupMode);
+    const forwardThinking = typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
+    const forwardToolCalls = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
+    const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        name: CHANNEL_ID,
+        enabled,
+        configured: Boolean(websocketUrl && token && userId),
+        websocketUrl,
+        baseUrl,
+        token,
+        userId,
+        replyMode,
+        groupMode,
+        forwardThinking,
+        forwardToolCalls,
+        richInteractions,
+        allowFrom: [],
+        stream: readStream(channel.stream),
+        reconnect: readReconnect(channel.reconnect),
+        heartbeat: readHeartbeat(channel.heartbeat),
+        ack: readAck(channel.ack),
+    };
+}
+export function listOpenclawClawlingAccountIds() {
+    return [DEFAULT_ACCOUNT_ID];
+}