@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/dist/src/group-message-coalescer.js

@@ -0,0 +1,119 @@
+function formatTurnTime(timestamp) {
+    if (!Number.isFinite(timestamp))
+        return "unknown-time";
+    const time = new Date(timestamp);
+    if (Number.isNaN(time.getTime()))
+        return "unknown-time";
+    return time.toISOString();
+}
+function formatSenderRelation(turn) {
+    return turn.senderRelation || "peer_user";
+}
+function formatSenderProfileType(turn) {
+    if (turn.senderProfileType)
+        return turn.senderProfileType;
+    const relation = formatSenderRelation(turn);
+    return relation === "self_agent" || relation === "peer_agent" ? "agent" : "user";
+}
+function formatMessageBody(rawBody) {
+    return rawBody || "(empty message)";
+}
+function formatField(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+function formatMentionedUsers(turn) {
+    const mentionedUsers = turn.mentionedUsers && turn.mentionedUsers.length > 0
+        ? turn.mentionedUsers
+        : turn.mentionedUserIds.map((id) => ({ id }));
+    if (mentionedUsers.length === 0)
+        return "-";
+    return mentionedUsers.map((mention) => {
+        const id = formatField(mention.id);
+        const display = mention.display?.trim();
+        return display ? `${id}(${formatField(display)})` : id;
+    }).join(",");
+}
+export function formatCoalescedGroupBody(turns, timing = { idleSeconds: 10, maxWaitSeconds: 30 }) {
+    const header = `ClawChat group batch (${turns.length} ${turns.length === 1 ? "message" : "messages"}, ${timing.idleSeconds}s idle, ${timing.maxWaitSeconds}s max):`;
+    return [
+        header,
+        turns.map((turn) => {
+            const senderName = turn.senderNickName || turn.senderId;
+            const senderIsAgentOwner = turn.senderIsOwner ?? formatSenderRelation(turn) === "owner";
+            return [
+                "[message]",
+                `sender_id: ${formatField(turn.senderId)}`,
+                `sender_name: ${formatField(senderName)}`,
+                `sender_profile_type: ${formatField(formatSenderProfileType(turn))}`,
+                `sender_is_agent_owner: ${senderIsAgentOwner ? "true" : "false"}`,
+                `sender_is_group_owner: ${turn.senderIsGroupOwner ? "true" : "false"}`,
+                `mentions_current_agent: ${turn.wasMentioned ? "true" : "false"}`,
+                `mentioned_users: ${formatMentionedUsers(turn)}`,
+                "text:",
+                formatMessageBody(turn.rawBody),
+            ].join("\n");
+        }).join("\n\n"),
+    ].join("\n");
+}
+export function mergeGroupTurns(turns, timing = { idleSeconds: 10, maxWaitSeconds: 30 }) {
+    if (turns.length === 0)
+        throw new Error("cannot merge empty group turn batch");
+    const latest = turns[turns.length - 1];
+    return {
+        ...latest,
+        rawBody: formatCoalescedGroupBody(turns, timing),
+        mediaItems: turns.flatMap((turn) => turn.mediaItems),
+        wasMentioned: turns.some((turn) => turn.wasMentioned),
+        mentionedUserIds: Array.from(new Set(turns.flatMap((turn) => turn.mentionedUserIds))),
+        mentionedUsers: Array.from(new Map(turns.flatMap((turn) => turn.mentionedUsers ?? turn.mentionedUserIds.map((id) => ({ id })))
+            .map((mention) => [mention.id, mention])).values()),
+        coalescedGroupBatch: true,
+    };
+}
+export function createGroupMessageCoalescer(params) {
+    const pending = new Map();
+    const timing = {
+        idleSeconds: Math.round(params.idleMs / 1000),
+        maxWaitSeconds: Math.round(params.maxWaitMs / 1000),
+    };
+    const flush = (chatId) => {
+        const batch = pending.get(chatId);
+        if (!batch)
+            return;
+        pending.delete(chatId);
+        clearTimeout(batch.idleTimer);
+        clearTimeout(batch.maxWaitTimer);
+        void params.dispatch(mergeGroupTurns(batch.turns, timing)).catch((error) => {
+            params.onError?.(error);
+        });
+    };
+    return {
+        enqueue(turn) {
+            const chatId = turn.peer.id;
+            const existing = pending.get(chatId);
+            if (existing) {
+                existing.turns.push(turn);
+                clearTimeout(existing.idleTimer);
+                existing.idleTimer = setTimeout(() => flush(chatId), params.idleMs);
+                return;
+            }
+            const idleTimer = setTimeout(() => flush(chatId), params.idleMs);
+            const maxWaitTimer = setTimeout(() => flush(chatId), params.maxWaitMs);
+            pending.set(chatId, { turns: [turn], idleTimer, maxWaitTimer });
+        },
+        flushNow(chatId) {
+            flush(chatId);
+        },
+        cancelAll() {
+            for (const [chatId, batch] of pending) {
+                clearTimeout(batch.idleTimer);
+                clearTimeout(batch.maxWaitTimer);
+                params.onDrop?.(chatId, batch.turns.length);
+            }
+            pending.clear();
+        },
+        pendingCount(chatId) {
+            return pending.get(chatId)?.turns.length ?? 0;
+        },
+    };
+}

package/dist/src/inbound.js

@@ -0,0 +1,170 @@
+import { EVENT, } from "./protocol-types.js";
+import { effectiveGroupMode } from "./config.js";
+import { extractMediaFragments, fragmentsToText } from "./message-mapper.js";
+import { hasRenderableText, isInboundMessagePayload } from "./protocol.js";
+function normalizeSender(sender) {
+    if (!sender || typeof sender !== "object")
+        return null;
+    const s = sender;
+    const id = typeof s.id === "string" ? s.id : "";
+    if (!id)
+        return null;
+    const nickName = typeof s.nick_name === "string" ? s.nick_name : id;
+    const profileType = s.type === "agent" || s.type === "user" ? s.type : null;
+    return { id, nickName, profileType };
+}
+function requireChatId(envelope) {
+    const chatId = envelope.chat_id;
+    return typeof chatId === "string" && chatId.trim() ? chatId : null;
+}
+function mentionIdFromRecord(record) {
+    const userId = record.user_id ?? record.userId ?? record.id;
+    return typeof userId === "string" && userId.length > 0 ? userId : undefined;
+}
+function mentionDisplayFromRecord(record) {
+    const display = record.display ?? record.label ?? record.name ?? record.nick_name ?? record.nickname;
+    return typeof display === "string" && display.trim() ? display.trim().replace(/^@/, "") : undefined;
+}
+function extractMentionUsers(fragments) {
+    return fragments
+        .filter((fragment) => fragment.kind === "mention")
+        .map((fragment) => {
+        const id = mentionIdFromRecord(fragment);
+        if (!id)
+            return null;
+        const display = mentionDisplayFromRecord(fragment);
+        return display ? { id, display } : { id };
+    })
+        .filter((mention) => mention !== null);
+}
+function normalizeMentionUsers(mentions) {
+    return mentions
+        .map((mention) => {
+        if (typeof mention === "string" && mention.length > 0)
+            return { id: mention };
+        if (mention && typeof mention === "object") {
+            const record = mention;
+            const id = mentionIdFromRecord(record);
+            if (!id)
+                return null;
+            const display = mentionDisplayFromRecord(record);
+            return display ? { id, display } : { id };
+        }
+        return null;
+    })
+        .filter((mention) => mention !== null);
+}
+function mergeMentionUsers(...sources) {
+    const merged = new Map();
+    for (const source of sources) {
+        for (const mention of source) {
+            const existing = merged.get(mention.id);
+            if (!existing || (!existing.display && mention.display)) {
+                merged.set(mention.id, mention);
+            }
+        }
+    }
+    return Array.from(merged.values());
+}
+function mentionedUserIds(mentions) {
+    return mentions.map((mention) => mention.id);
+}
+/**
+ * Exported for direct unit testing. Direct chats always count as addressed;
+ * group chats require a mention unless config opts into all group messages.
+ */
+export function detectMention(params) {
+    if (params.chatType === "direct")
+        return true;
+    return mentionedUserIds(normalizeMentionUsers(params.mentions)).includes(params.userId);
+}
+export async function dispatchOpenclawClawlingInbound(params) {
+    const { envelope, account, log } = params;
+    const isMaterializedMessage = envelope.event === EVENT.MESSAGE_SEND || envelope.event === EVENT.MESSAGE_REPLY;
+    if (!isMaterializedMessage) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip non-business event=${envelope.event} trace=${envelope.trace_id}`);
+        return;
+    }
+    if (isMaterializedMessage && !isInboundMessagePayload(envelope.payload)) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip: invalid payload trace=${envelope.trace_id}`);
+        return;
+    }
+    const chatId = requireChatId(envelope);
+    if (!chatId) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip: missing chat_id trace=${envelope.trace_id}`);
+        return;
+    }
+    const payload = envelope.payload;
+    const message = payload.message;
+    const sender = normalizeSender(envelope.sender);
+    if (!sender) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip: missing sender trace=${envelope.trace_id}`);
+        return;
+    }
+    if (account.userId && sender.id === account.userId) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip self-echo msg=${payload.message_id} user=${sender.id}`);
+        return;
+    }
+    const chatType = envelope.chat_type === "group" ? "group" : "direct";
+    const isGroup = chatType === "group";
+    if (isMaterializedMessage && payload.message_mode !== "normal") {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip non-normal mode=${payload.message_mode}`);
+        return;
+    }
+    if (!hasRenderableText(message)) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip empty msg=${payload.message_id}`);
+        return;
+    }
+    const fragmentMentionUsers = extractMentionUsers(message.body.fragments);
+    const contextMentionUsers = normalizeMentionUsers(message.context.mentions);
+    const mentionedUsers = mergeMentionUsers(fragmentMentionUsers, contextMentionUsers);
+    const mentionIds = mentionedUserIds(mentionedUsers);
+    const rawBody = fragmentsToText(message.body.fragments, {
+        mentionFallbackIds: mentionIds,
+    });
+    const mediaItems = extractMediaFragments(message.body.fragments);
+    const wasMentioned = detectMention({
+        mentions: mentionIds,
+        chatType,
+        userId: account.userId,
+    });
+    // Group trigger policy: in "mention" mode we only handle group messages
+    // that @-mention us; "all" listens open and processes every group msg.
+    // Direct chats are unaffected (detectMention returns true).
+    const groupMode = isGroup ? effectiveGroupMode(account, chatId) : account.groupMode;
+    if (isGroup && groupMode === "mention" && !wasMentioned) {
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip group (no mention) msg=${payload.message_id}`);
+        return;
+    }
+    log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw inbound event=${envelope.event} msg=${payload.message_id} from=${sender.id} text_len=${rawBody.length} mentioned=${wasMentioned}`);
+    const replyCtx = message.context.reply
+        ? {
+            replyToMessageId: message.context.reply.reply_to_msg_id,
+            replyPreviewChatId: chatId,
+            replyPreviewSenderId: message.context.reply.reply_preview.id ?? "",
+            replyPreviewNickName: message.context.reply.reply_preview.nick_name ?? "",
+            replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments),
+        }
+        : undefined;
+    await params.ingest({
+        channel: "clawchat-plugin-openclaw",
+        accountId: account.accountId,
+        peer: { kind: isGroup ? "group" : "direct", id: chatId },
+        senderId: sender.id,
+        senderNickName: sender.nickName,
+        ...(sender.profileType ? { senderProfileType: sender.profileType } : {}),
+        rawBody,
+        messageId: payload.message_id,
+        traceId: envelope.trace_id,
+        timestamp: envelope.emitted_at,
+        wasMentioned,
+        mentionedUserIds: mentionIds,
+        mentionedUsers,
+        mediaItems,
+        ...(replyCtx ? { replyCtx } : {}),
+        cfg: params.cfg,
+        runtime: params.runtime,
+        account,
+        envelope,
+    });
+}

package/dist/src/llm-context-debug.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+function envEnabled(value) {
+    return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
+}
+function safeId(value) {
+    const text = String(value ?? "unknown").replace(/[^A-Za-z0-9_.-]+/g, "-");
+    return text.length > 0 ? text.slice(0, 80) : "unknown";
+}
+export function createOpenclawLlmContextDebug(params = {}) {
+    const env = params.env ?? process.env;
+    const enabled = envEnabled(env.CLAWCHAT_LLM_CONTEXT_DEBUG);
+    const snapshotRoot = path.resolve(env.CLAWCHAT_LLM_CONTEXT_SNAPSHOT_DIR || params.defaultSnapshotRoot || ".clawchat-llm-context-debug");
+    return {
+        enabled,
+        captureFullInput: envEnabled(env.CLAWCHAT_LLM_CONTEXT_CAPTURE_FULL_INPUT),
+        captureOutput: envEnabled(env.CLAWCHAT_LLM_CONTEXT_CAPTURE_OUTPUT),
+        reloadPrompts: envEnabled(env.CLAWCHAT_LLM_CONTEXT_RELOAD_PROMPTS),
+        snapshotRoot,
+        writeSnapshot(snapshot) {
+            if (!enabled)
+                return null;
+            const createdAt = new Date().toISOString();
+            const targetRoot = path.join(snapshotRoot, "openclaw");
+            const runsRoot = path.join(targetRoot, "runs");
+            fs.mkdirSync(runsRoot, { recursive: true });
+            const messageId = safeId(snapshot.trace.messageId);
+            const traceId = safeId(snapshot.trace.traceId);
+            const filePath = path.join(runsRoot, `${createdAt.replace(/[:.]/g, "-")}-${messageId}-${traceId}.json`);
+            const body = {
+                schemaVersion: 1,
+                source: "openclaw",
+                visibility: snapshot.visibility,
+                createdAt,
+                trace: snapshot.trace,
+                context: {
+                    promptParts: snapshot.context?.promptParts ?? [],
+                    tools: snapshot.context?.tools ?? [],
+                    skills: snapshot.context?.skills ?? [],
+                },
+                input: {
+                    injectedPrompt: snapshot.input.injectedPrompt ?? "",
+                    eventText: snapshot.input.eventText ?? "",
+                    fullLlmInput: snapshot.input.fullLlmInput ?? null,
+                    sections: snapshot.input.sections ?? [],
+                },
+                output: {
+                    rawModelOutput: snapshot.output?.rawModelOutput ?? null,
+                    streamChunks: snapshot.output?.streamChunks ?? [],
+                    toolCalls: snapshot.output?.toolCalls ?? [],
+                    toolResults: snapshot.output?.toolResults ?? [],
+                    finalAssistantText: snapshot.output?.finalAssistantText ?? null,
+                    adapterFilteredText: snapshot.output?.adapterFilteredText ?? null,
+                    outboundClawChatMessage: snapshot.output?.outboundClawChatMessage ?? null,
+                    suppressed: snapshot.output?.suppressed ?? false,
+                    suppressionReason: snapshot.output?.suppressionReason ?? null,
+                },
+                warnings: snapshot.warnings ?? [],
+            };
+            const text = `${JSON.stringify(body, null, 2)}\n`;
+            fs.writeFileSync(filePath, text, "utf8");
+            fs.writeFileSync(path.join(targetRoot, "latest.json"), text, "utf8");
+            return filePath;
+        },
+    };
+}
+export const openclawLlmContextDebug = {
+    get enabled() {
+        return createOpenclawLlmContextDebug().enabled;
+    },
+    get captureFullInput() {
+        return createOpenclawLlmContextDebug().captureFullInput;
+    },
+    get captureOutput() {
+        return createOpenclawLlmContextDebug().captureOutput;
+    },
+    get reloadPrompts() {
+        return createOpenclawLlmContextDebug().reloadPrompts;
+    },
+    get snapshotRoot() {
+        return createOpenclawLlmContextDebug().snapshotRoot;
+    },
+    writeSnapshot(snapshot) {
+        return createOpenclawLlmContextDebug().writeSnapshot(snapshot);
+    },
+};

package/dist/src/login.runtime.js

@@ -0,0 +1,204 @@
+import { createInterface } from "node:readline/promises";
+import { createOpenclawClawlingApiClient } from "./api-client.js";
+import { ClawlingApiError } from "./api-types.js";
+import { CHANNEL_ID, mergeOpenclawClawchatRuntimePluginActivation, mergeOpenclawClawchatToolAllow, resolveOpenclawClawlingAccount, } from "./config.js";
+import { getClawChatStore } from "./storage.js";
+/**
+ * Platform tag sent to `/v1/agents/connect`. Identifies the host of this
+ * agent runtime — openclaw's bundled clawchat channel.
+ */
+export const AGENTS_CONNECT_PLATFORM = "openclaw";
+/**
+ * Agent type tag sent to `/v1/agents/connect`. The clawchat channel is
+ * always a bot; humans don't log in through this flow.
+ */
+export const AGENTS_CONNECT_TYPE = "clawbot";
+/**
+ * Prompt the operator for an invite code.
+ *
+ * The prompt text is emitted via `runtime.log` so it flows through the
+ * same openclaw logging pipeline every other channel plugin uses (no
+ * clack frame, no raw-mode takeover, no TTY detection). Input is read
+ * from stdin with `node:readline` — Enter-to-submit is plain language in
+ * the prompt so any upstream LLM / orchestrator reading the log stream
+ * knows a newline is expected, and the behavior is identical under a
+ * TTY, piped stdin, or a test harness.
+ */
+async function promptInviteCodeFromStdin(runtime) {
+    runtime.log("Please enter your ClawChat invite code (press Enter to submit):");
+    let rl;
+    try {
+        rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question("> ");
+        return answer.trim();
+    }
+    finally {
+        rl?.close();
+    }
+}
+function buildLoginConfig(cfg, result) {
+    const channels = (cfg.channels ?? {});
+    const existing = (channels[CHANNEL_ID] ?? {});
+    const groupMode = existing.groupMode === "mention" || existing.groupMode === "all"
+        ? existing.groupMode
+        : "all";
+    const groupCommandMode = existing.groupCommandMode === "all" || existing.groupCommandMode === "off"
+        ? existing.groupCommandMode
+        : "owner";
+    const nextSection = {
+        ...existing,
+        enabled: true,
+        groupMode,
+        groupCommandMode,
+        token: result.access_token,
+        ...(result.agent.id ? { agentId: result.agent.id } : {}),
+        userId: result.agent.user_id,
+        ownerUserId: result.agent.owner_id,
+    };
+    if (result.refresh_token) {
+        nextSection.refreshToken = result.refresh_token;
+    }
+    else {
+        delete nextSection.refreshToken;
+    }
+    return mergeOpenclawClawchatRuntimePluginActivation(mergeOpenclawClawchatToolAllow({
+        ...cfg,
+        channels: { ...channels, [CHANNEL_ID]: nextSection },
+    }));
+}
+async function persistLoginConfig(params, result) {
+    if (params.mutateConfigFile) {
+        params.runtime.log(`Persisting ClawChat credentials and plugin activation for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id} with Gateway restart intent.`);
+        await params.mutateConfigFile({
+            afterWrite: {
+                mode: "restart",
+                reason: "clawchat-plugin-openclaw credentials changed",
+            },
+            mutate(draft) {
+                Object.assign(draft, buildLoginConfig(draft, result));
+            },
+        });
+        params.runtime.log(`ClawChat credentials and plugin activation persisted for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id}.`);
+        return;
+    }
+    if (params.persistConfig) {
+        params.runtime.log(`Persisting ClawChat credentials and plugin activation for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id}.`);
+        await params.persistConfig(buildLoginConfig(params.cfg, result));
+        params.runtime.log(`ClawChat credentials and plugin activation persisted for userId=${result.agent.user_id} ownerUserId=${result.agent.owner_id}.`);
+        return;
+    }
+    throw new Error("clawchat-plugin-openclaw: mutateConfigFile is required to persist login credentials");
+}
+function requireConnectString(value, fieldName) {
+    if (typeof value !== "string") {
+        throw new Error(`agents/connect response missing required fields (${fieldName})`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`agents/connect response missing required fields (${fieldName})`);
+    }
+    return trimmed;
+}
+function readOptionalConnectString(value, fieldName) {
+    if (value == null) {
+        return undefined;
+    }
+    return requireConnectString(value, fieldName);
+}
+/**
+ * Run the invite-code credential exchange used by `/clawchat-activate`,
+ * `openclaw channels add --channel clawchat-plugin-openclaw --token <invite-code>`,
+ * and `openclaw channels login --channel clawchat-plugin-openclaw`:
+ *   1. Read the existing channel section; require `baseUrl` to be set so we
+ *      know which server to hit.
+ *   2. Prompt the user for an invite code on stdin.
+ *   3. POST it to `${baseUrl}/v1/agents/connect`.
+ *   4. Write the returned `websocket_url` / `token` / `user_id` back into
+ *      the config so subsequent Gateway runs pick them up.
+ *
+ * Errors surface with clear messages (missing baseUrl, empty invite,
+ * server-side rejection) so the caller can relay them to the operator.
+ */
+export async function runOpenclawClawlingLogin(params) {
+    const { cfg, runtime } = params;
+    // `resolveOpenclawClawlingAccount` falls back to the built-in
+    // `DEFAULT_BASE_URL` / `DEFAULT_WEBSOCKET_URL` when the operator has not
+    // overridden them, so login works without a prior `openclaw channels setup --channel clawchat-plugin-openclaw`.
+    const account = resolveOpenclawClawlingAccount(cfg);
+    const inviteCode = (await (params.readInviteCode ?? (() => promptInviteCodeFromStdin(runtime)))()).trim();
+    if (!inviteCode) {
+        throw new Error("Login aborted: invite code is required.");
+    }
+    const apiClient = (params.apiClientFactory ?? createOpenclawClawlingApiClient)({
+        baseUrl: account.baseUrl,
+        // Pre-login we may not have a token yet. Send the current one (or empty)
+        // — the server should accept an unauthenticated invite-code exchange.
+        token: account.token || "",
+    });
+    runtime.log("Verifying invite code …");
+    let result;
+    try {
+        result = await apiClient.agentsConnect({
+            code: inviteCode,
+            platform: AGENTS_CONNECT_PLATFORM,
+            type: AGENTS_CONNECT_TYPE,
+        });
+    }
+    catch (err) {
+        if (err instanceof ClawlingApiError) {
+            throw new Error(`agents/connect failed (${err.kind}): ${err.message}`);
+        }
+        throw err;
+    }
+    const accessToken = requireConnectString(result?.access_token, "access_token");
+    const agentUserId = requireConnectString(result?.agent?.user_id, "agent.user_id");
+    const ownerUserId = requireConnectString(result?.agent?.owner_id, "agent.owner_id");
+    const agentId = readOptionalConnectString(result?.agent?.id, "agent.id");
+    let conversationId = null;
+    if (result?.conversation != null) {
+        conversationId = requireConnectString(result.conversation.id, "conversation.id");
+    }
+    const normalizedResult = {
+        ...result,
+        access_token: accessToken,
+        refresh_token: typeof result?.refresh_token === "string" ? result.refresh_token.trim() : "",
+        agent: {
+            ...result.agent,
+            ...(agentId ? { id: agentId } : {}),
+            owner_id: ownerUserId,
+            user_id: agentUserId,
+        },
+        ...(conversationId
+            ? {
+                conversation: {
+                    ...result.conversation,
+                    id: conversationId,
+                },
+            }
+            : {}),
+    };
+    runtime.log(`Updating config: channels.${CHANNEL_ID}.token=[REDACTED] agentId=${normalizedResult.agent.id || "-"} userId=${normalizedResult.agent.user_id} ownerUserId=${normalizedResult.agent.owner_id}${normalizedResult.refresh_token ? " refreshToken=[REDACTED]" : ""} plugins.entries.${CHANNEL_ID}.enabled=true plugins.allow+=${CHANNEL_ID} …`);
+    await persistLoginConfig(params, normalizedResult);
+    try {
+        const store = params.store ??
+            getClawChatStore({
+                ...(params.dbPath ? { dbPath: params.dbPath } : {}),
+                log: { error: runtime.log },
+            });
+        store.upsertActivation({
+            platform: "openclaw",
+            accountId: account.accountId,
+            userId: normalizedResult.agent.user_id,
+            ownerUserId: normalizedResult.agent.owner_id,
+            accessToken: normalizedResult.access_token,
+            refreshToken: normalizedResult.refresh_token || null,
+            conversationId: normalizedResult.conversation?.id ?? null,
+            loginMethod: "login",
+        });
+    }
+    catch {
+        runtime.log("clawchat-plugin-openclaw sqlite activation persistence failed; login continues.");
+    }
+    runtime.log(`Config file updated.`);
+    runtime.log(`clawchat-plugin-openclaw login succeeded (user_id=${normalizedResult.agent.user_id}, owner_user_id=${normalizedResult.agent.owner_id}, nickname=${normalizedResult.agent.nickname || "-"}).`);
+}

package/dist/src/media-runtime.js

@@ -0,0 +1,85 @@
+import { buildOutboundMediaLoadOptions, } from "openclaw/plugin-sdk/media-runtime";
+export function inferMediaKindFromMime(mime) {
+    if (!mime)
+        return "file";
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime.startsWith("video/"))
+        return "video";
+    return "file";
+}
+const DEFAULT_MEDIA_MAX_BYTES = 20 * 1024 * 1024;
+/**
+ * Fetch each remote URL via the shared media runtime, persist to a local
+ * cache, and return the list of local paths.
+ *
+ * Failed items are logged at info level and dropped; the remaining items
+ * still resolve so a single bad URL doesn't blow up the whole inbound turn.
+ */
+export async function fetchInboundMedia(items, ctx) {
+    if (items.length === 0)
+        return [];
+    const maxBytes = ctx.maxBytes ?? DEFAULT_MEDIA_MAX_BYTES;
+    const paths = [];
+    for (const item of items) {
+        try {
+            const fetched = await ctx.runtime.channel.media.fetchRemoteMedia({
+                url: item.url,
+                maxBytes,
+            });
+            const saved = await ctx.runtime.channel.media.saveMediaBuffer(fetched.buffer, fetched.contentType ?? item.mime, "clawchat-plugin-openclaw-inbound", maxBytes, item.name ?? fetched.fileName);
+            paths.push(saved.path);
+        }
+        catch (err) {
+            ctx.log?.info?.(`clawchat-plugin-openclaw inbound media skipped: ${item.url} (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    return paths;
+}
+/**
+ * Upload each URL (remote or local path) to /media/upload via the api
+ * client and return a fragment ready to splice into `body.fragments`.
+ *
+ * Uses the host runtime's `runtime.media.loadWebMedia`, so local-root
+ * enforcement and media-loading policy stay aligned with the current
+ * OpenClaw runtime instead of a directly imported helper.
+ *
+ * Single-upload failures log at error and are dropped; the remaining
+ * fragments still come back so a partially-failing batch still sends the
+ * working media.
+ */
+export async function uploadOutboundMedia(urls, ctx) {
+    if (urls.length === 0)
+        return [];
+    const maxBytes = ctx.maxBytes ?? DEFAULT_MEDIA_MAX_BYTES;
+    const out = [];
+    for (const url of urls) {
+        try {
+            const loaded = await ctx.runtime.media.loadWebMedia(url, buildOutboundMediaLoadOptions({
+                maxBytes,
+                ...(ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {}),
+                ...(ctx.mediaLocalRoots ? { mediaLocalRoots: ctx.mediaLocalRoots } : {}),
+                ...(ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}),
+            }));
+            const uploaded = await ctx.apiClient.uploadMedia({
+                buffer: loaded.buffer,
+                filename: loaded.fileName ?? "upload.bin",
+                mime: loaded.contentType,
+            });
+            const fragment = {
+                kind: uploaded.kind,
+                url: uploaded.url,
+                name: uploaded.name,
+                mime: uploaded.mime,
+                size: uploaded.size,
+            };
+            out.push(fragment);
+        }
+        catch (err) {
+            ctx.log?.error?.(`clawchat-plugin-openclaw outbound media upload failed: ${url} (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    return out;
+}