@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/dist/src/clawchat-metadata.js

@@ -0,0 +1,235 @@
+import { readClawChatMemoryFile, writeClawChatMetadata, } from "./clawchat-memory.js";
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function stringField(record, key) {
+    if (!hasOwn(record, key))
+        return undefined;
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function addStringField(metadata, outputKey, record, inputKey = outputKey) {
+    const value = stringField(record, inputKey);
+    if (value !== undefined)
+        metadata[outputKey] = value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function ownerMetadataFromAgent(agent, params) {
+    const metadata = {};
+    addStringField(metadata, "updated_at", agent);
+    const agentId = stringField(agent, "user_id") ?? params.accountUserId;
+    if (agentId !== undefined)
+        metadata.agent_id = agentId;
+    const ownerId = stringField(agent, "owner_id") ?? params.accountOwnerUserId;
+    if (ownerId !== undefined)
+        metadata.owner_id = ownerId;
+    addStringField(metadata, "nickname", agent);
+    addStringField(metadata, "avatar_url", agent);
+    addStringField(metadata, "bio", agent);
+    addStringField(metadata, "behavior", agent);
+    return metadata;
+}
+function userMetadataFromRecord(record, targetUserId) {
+    const metadata = {};
+    addStringField(metadata, "updated_at", record);
+    metadata.id = targetUserId;
+    addStringField(metadata, "nickname", record);
+    addStringField(metadata, "avatar_url", record);
+    addStringField(metadata, "bio", record);
+    addStringField(metadata, "profile_type", record, "type");
+    return metadata;
+}
+function userMetadataFromProfile(profile, userId) {
+    const metadata = userMetadataFromRecord(profile, userId);
+    if (metadata === null) {
+        throw new Error("ClawChat user metadata response is missing id");
+    }
+    return metadata;
+}
+function participantUserMetadata(participant) {
+    const userRecord = asRecord(participant.user);
+    const source = userRecord ?? participant;
+    const userId = stringField(source, "id") ?? stringField(participant, "user_id");
+    if (!userId)
+        return null;
+    const metadata = userMetadataFromRecord(source, userId);
+    return metadata ? { userId, metadata } : null;
+}
+function groupMetadataFromConversation(conversation, groupId) {
+    const record = conversation;
+    const metadata = {};
+    addStringField(metadata, "updated_at", record);
+    metadata.id = groupId;
+    addStringField(metadata, "type", record);
+    addStringField(metadata, "title", record);
+    addStringField(metadata, "description", record);
+    addStringField(metadata, "creator_id", record);
+    addStringField(metadata, "created_at", record);
+    return metadata;
+}
+function pickUpdatePatch(patchInput, keys) {
+    const patch = {};
+    for (const key of keys) {
+        if (hasOwn(patchInput, key) && typeof patchInput[key] === "string") {
+            patch[key] = patchInput[key];
+        }
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error("ClawChat metadata update must include at least one mutable field");
+    }
+    return patch;
+}
+export async function pullOwnerMetadata(params) {
+    const getAgent = params.api.getAgentDetail ?? params.api.getAgentProfile;
+    if (!getAgent)
+        throw new Error("ClawChat metadata pull requires getAgentDetail");
+    if (!params.agentId)
+        throw new Error("ClawChat owner metadata pull requires agentId");
+    const data = await getAgent(params.agentId);
+    const metadata = ownerMetadataFromAgent(asRecord(data.agent) ?? {}, params);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+    return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [] };
+}
+export async function pullUserMetadata(params) {
+    const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+    if (!getUser)
+        throw new Error("ClawChat metadata pull requires getUserProfile");
+    const profile = await getUser(params.userId);
+    const metadata = userMetadataFromProfile(profile, params.userId);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.userId }, metadata);
+    return { ok: true, writes: [{ targetType: "user", targetId: params.userId }], failures: [] };
+}
+export async function pullGroupMetadata(params) {
+    if (!params.api.getConversation)
+        throw new Error("ClawChat metadata pull requires getConversation");
+    const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+    const data = await params.api.getConversation(params.groupId);
+    const writes = [];
+    const failures = [];
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "group", targetId: params.groupId }, groupMetadataFromConversation(data.conversation, params.groupId));
+    writes.push({ targetType: "group", targetId: params.groupId });
+    const participants = Array.isArray(data.conversation.participants)
+        ? data.conversation.participants
+        : [];
+    for (const participant of participants) {
+        const mapped = participantUserMetadata(participant);
+        if (!mapped)
+            continue;
+        try {
+            const existing = await readClawChatMemoryFile(params.memoryRoot, {
+                targetType: "user",
+                targetId: mapped.userId,
+            });
+            if (existing.exists)
+                continue;
+            if (!getUser)
+                throw new Error("ClawChat participant metadata pull requires getUserProfile");
+            const profile = await getUser(mapped.userId);
+            const metadata = userMetadataFromProfile(profile, mapped.userId);
+            await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: mapped.userId }, metadata);
+            writes.push({ targetType: "user", targetId: mapped.userId });
+        }
+        catch (error) {
+            failures.push({ targetType: "user", targetId: mapped.userId, error: errorMessage(error) });
+        }
+    }
+    return { ok: failures.length === 0, writes, failures, conversation: data.conversation };
+}
+export async function pushMetadata(params) {
+    const file = await readClawChatMemoryFile(params.memoryRoot, {
+        targetType: params.targetType,
+        targetId: params.targetId,
+    });
+    return await updateMetadata({
+        memoryRoot: params.memoryRoot,
+        targetType: params.targetType,
+        targetId: params.targetId,
+        agentId: params.agentId,
+        accountUserId: params.accountUserId,
+        patch: pickPushPatch(params.targetType, params.targetId, file.metadata, {
+            fields: params.fields,
+            agentId: params.agentId,
+            accountUserId: params.accountUserId,
+        }),
+        api: params.api,
+    });
+}
+function mutableFieldsForTarget(targetType, targetId, params) {
+    if (targetType === "owner") {
+        if (targetId !== "owner")
+            throw new Error("ClawChat owner metadata targetId must be owner");
+        if (!params.agentId)
+            throw new Error("ClawChat owner metadata update requires agentId");
+        return ["nickname", "avatar_url", "bio", "behavior"];
+    }
+    if (targetType === "user") {
+        if (!params.accountUserId)
+            throw new Error("ClawChat user metadata update requires accountUserId");
+        if (targetId !== params.accountUserId) {
+            throw new Error("ClawChat user metadata update is allowed only for the connected user");
+        }
+        return ["nickname", "avatar_url", "bio"];
+    }
+    return ["title", "description"];
+}
+function pickPushPatch(targetType, targetId, metadata, params) {
+    if (!Array.isArray(params.fields) || params.fields.length === 0) {
+        throw new Error("fields are required for metadata push");
+    }
+    const allowed = mutableFieldsForTarget(targetType, targetId, params);
+    const patch = {};
+    for (const field of params.fields) {
+        if (typeof field !== "string" || field.length === 0) {
+            throw new Error("fields must contain non-empty strings");
+        }
+        if (!allowed.includes(field)) {
+            throw new Error(`fields contain non-pushable metadata field: ${field}`);
+        }
+        if (!hasOwn(metadata, field)) {
+            throw new Error(`missing_metadata_field: ${field}`);
+        }
+        patch[field] = metadata[field];
+    }
+    return patch;
+}
+export async function updateMetadata(params) {
+    if (params.targetType === "owner") {
+        if (!params.agentId)
+            throw new Error("ClawChat owner metadata update requires agentId");
+        if (!params.api.patchAgent)
+            throw new Error("ClawChat owner metadata update requires patchAgent");
+        const patch = pickUpdatePatch(params.patch, ["nickname", "avatar_url", "bio", "behavior"]);
+        const response = await params.api.patchAgent(params.agentId, patch);
+        const metadata = ownerMetadataFromAgent(response.agent, {
+            accountUserId: params.accountUserId,
+        });
+        await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+        return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [], metadata };
+    }
+    if (params.targetType === "user") {
+        if (!params.accountUserId)
+            throw new Error("ClawChat user metadata update requires accountUserId");
+        if (params.targetId !== params.accountUserId) {
+            throw new Error("ClawChat user metadata update is allowed only for the connected user");
+        }
+        if (!params.api.updateMyProfile)
+            throw new Error("ClawChat user metadata update requires updateMyProfile");
+        const patch = pickUpdatePatch(params.patch, ["nickname", "avatar_url", "bio"]);
+        const profile = await params.api.updateMyProfile(patch);
+        const metadata = userMetadataFromProfile(profile, params.targetId);
+        await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.targetId }, metadata);
+        return { ok: true, writes: [{ targetType: "user", targetId: params.targetId }], failures: [], metadata };
+    }
+    if (!params.api.patchConversation)
+        throw new Error("ClawChat group metadata update requires patchConversation");
+    const patch = pickUpdatePatch(params.patch, ["title", "description"]);
+    const response = await params.api.patchConversation(params.targetId, patch);
+    const metadata = groupMetadataFromConversation(response.conversation, params.targetId);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "group", targetId: params.targetId }, metadata);
+    return { ok: true, writes: [{ targetType: "group", targetId: params.targetId }], failures: [], metadata };
+}

package/dist/src/client.js

@@ -1,74 +1,17 @@
-import { createWSClient, } from "@newbase-clawchat/sdk";
-function createMsghubConnectTransport(account, transport, lifecycle) {
-    const maybeWrapped = transport;
-    if (maybeWrapped.__openclawInnerTransport)
-        return transport;
-    const wrapped = {
-        __openclawInnerTransport: transport,
-        get state() {
-            return transport.state;
-        },
-        connect(url, handlers) {
-            return transport.connect(url, handlers);
-        },
-        send(data) {
-            let parsed;
-            try {
-                parsed = JSON.parse(data);
-            }
-            catch {
-                transport.send(data);
-                return;
-            }
-            if (!parsed ||
-                typeof parsed !== "object" ||
-                parsed.event !== "connect") {
-                transport.send(data);
-                return;
-            }
-            const env = parsed;
-            const nonce = typeof env.payload?.nonce === "string" ? env.payload.nonce : "";
-            const payload = {
-                token: account.token,
-                nonce,
-                ...(account.userId ? { device_id: account.userId } : {}),
-                capabilities: {
-                    multi_device: true,
-                    device_replay: true,
-                },
-            };
-            const connectEnv = { ...env, payload };
-            transport.send(JSON.stringify(connectEnv));
-            lifecycle?.onConnectFrameSent?.(connectEnv);
-        },
-        close(code, reason) {
-            transport.close(code, reason);
-        },
-    };
-    return wrapped;
-}
-function installMsghubConnectTransport(account, client, lifecycle) {
-    const inner = client;
-    if (!inner.opts?.transport)
-        return;
-    inner.opts.transport = createMsghubConnectTransport(account, inner.opts.transport, lifecycle);
-}
+import { createClawChatClient } from "./ws-client.js";
 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 = {
+    const client = createClawChatClient({
         url: account.websocketUrl,
         token: account.token,
-        reconnect,
+        deviceId: account.userId,
+        ...(overrides.transport ? { transport: overrides.transport } : {}),
+        reconnect: {
+            enabled: true,
+            initialDelay: account.reconnect.initialDelay,
+            maxDelay: account.reconnect.maxDelay,
+            jitterRatio: account.reconnect.jitterRatio,
+            maxRetries: account.reconnect.maxRetries,
+        },
         heartbeat: {
             enabled: true,
             interval: account.heartbeat.interval,
@@ -78,14 +21,16 @@ export function createOpenclawClawlingClient(account, overrides = {}) {
             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 } : {}),
-    };
-    const client = createWSClient(options);
-    installMsghubConnectTransport(account, client, overrides.wsLifecycle);
+    });
+    if (overrides.wsLifecycle?.onConnectFrameSent) {
+        const sendRawEnvelope = client.sendRawEnvelope.bind(client);
+        client.sendRawEnvelope = (env) => {
+            sendRawEnvelope(env);
+            if (env.event === "connect") {
+                overrides.wsLifecycle?.onConnectFrameSent?.(env);
+            }
+        };
+    }
     return client;
 }
 function normalizeRouting(params) {
@@ -97,31 +42,26 @@ function normalizeRouting(params) {
     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.
+ * Emit a raw v2 envelope through the local client so stream helpers carry
+ * top-level `chat_id` routing without legacy `to` metadata.
  */
 function emitEnvelope(client, event, payload, routing, options = {}) {
-    const inner = client;
-    if (!options.forceRawTransport && inner.emitRaw) {
-        inner.emitRaw(event, payload, { chat_id: routing.chatId });
+    if (!options.forceRawTransport) {
+        client.emitRaw(event, payload, { chat_id: routing.chatId });
         return;
     }
-    if (!inner.opts?.transport) {
-        if (!options.forceRawTransport && inner.emitRaw) {
-            inner.emitRaw(event, payload, { chat_id: routing.chatId });
-            return;
-        }
-        throw new Error("openclaw-clawchat streaming emit requires SDK raw transport");
+    if (typeof client.nextTraceId !== "function" || typeof client.sendRawEnvelope !== "function") {
+        throw new Error("openclaw-clawchat streaming emit requires local raw transport");
     }
     const env = {
         version: "2",
         event,
-        trace_id: inner.opts.traceIdFactory(),
+        trace_id: client.nextTraceId(),
         emitted_at: Date.now(),
         chat_id: routing.chatId,
         payload,
     };
-    inner.opts.transport.send(JSON.stringify(env));
+    client.sendRawEnvelope(env);
 }
 /**
  * Emit a minimal `message.created` envelope to open a streaming message.
@@ -189,10 +129,8 @@ export function emitStreamDone(client, params) {
  * 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.
+ * Final stream replies include the correlated `payload.message_id`, so they
+ * use the local raw-envelope API instead of any higher-level ackable send.
  */
 export function emitFinalStreamReply(client, params) {
     const routing = normalizeRouting(params);

package/dist/src/commands.js

@@ -7,14 +7,14 @@ function errorMessage(err) {
 }
 export function registerOpenclawClawlingCommands(api) {
     api.registerCommand({
-        name: "clawchat-login",
-        description: "Activate ClawChat with an invite code, e.g. /clawchat-login A1B2C3.",
+        name: "clawchat-activate",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-activate 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" };
+                return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
             }
             try {
                 const { runOpenclawClawlingLogin } = await import("./login.runtime.js");

package/dist/src/config.js

@@ -1,7 +1,9 @@
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "openclaw-clawchat";
 export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
+export const CLAWCHAT_AGENT_ID_ENV = "CLAWCHAT_AGENT_ID";
 export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID";
+export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_USER_ID";
 export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN";
 export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL";
 export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
@@ -51,9 +53,23 @@ export const openclawClawlingConfigSchema = {
         baseUrl: { type: "string" },
         token: { type: "string" },
         refreshToken: { type: "string" },
+        agentId: { type: "string" },
         userId: { type: "string" },
+        ownerUserId: { type: "string" },
         replyMode: { type: "string", enum: ["static", "stream"] },
         groupMode: { type: "string", enum: ["mention", "all"] },
+        groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+        groups: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    groupMode: { type: "string", enum: ["mention", "all"] },
+                    groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+                },
+            },
+        },
         forwardThinking: { type: "boolean" },
         forwardToolCalls: { type: "boolean" },
         richInteractions: { type: "boolean" },
@@ -165,10 +181,41 @@ function readEnvString(env, key) {
     return readOptionalString(env[key]);
 }
 function readReplyMode(value) {
-    return value === "stream" ? "stream" : "static";
+    return value === "static" ? "static" : "stream";
 }
 function readGroupMode(value) {
-    return value === "all" ? "all" : "mention";
+    return value === "mention" ? "mention" : "all";
+}
+function readGroupCommandMode(value) {
+    return value === "all" || value === "off" ? value : "owner";
+}
+function readGroups(value) {
+    const rawGroups = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const groups = {};
+    for (const [chatId, rawGroup] of Object.entries(rawGroups)) {
+        if (!chatId)
+            continue;
+        const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
+            ? rawGroup
+            : {};
+        groups[chatId] = {
+            groupMode: readGroupMode(group.groupMode),
+            groupCommandMode: readGroupCommandMode(group.groupCommandMode),
+        };
+    }
+    return groups;
+}
+export function effectiveGroupMode(account, chatId) {
+    return account.groups[chatId]?.groupMode
+        ?? account.groups["*"]?.groupMode
+        ?? account.groupMode;
+}
+export function effectiveGroupCommandMode(account, chatId) {
+    return account.groups[chatId]?.groupCommandMode
+        ?? account.groups["*"]?.groupCommandMode
+        ?? account.groupCommandMode;
 }
 function readStream(raw) {
     const s = raw && typeof raw === "object" ? raw : {};
@@ -215,10 +262,14 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
         DEFAULT_BASE_URL;
     const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
+    const agentId = readOptionalString(channel.agentId) || readEnvString(env, CLAWCHAT_AGENT_ID_ENV);
     const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
+    const ownerUserId = readOptionalString(channel.ownerUserId) || readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV);
     const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
     const replyMode = readReplyMode(channel.replyMode);
     const groupMode = readGroupMode(channel.groupMode);
+    const groupCommandMode = readGroupCommandMode(channel.groupCommandMode);
+    const groups = readGroups(channel.groups);
     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;
@@ -226,13 +277,17 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         accountId: DEFAULT_ACCOUNT_ID,
         name: CHANNEL_ID,
         enabled,
-        configured: Boolean(websocketUrl && token && userId),
+        configured: Boolean(websocketUrl && token && userId && ownerUserId),
         websocketUrl,
         baseUrl,
         token,
+        agentId,
         userId,
+        ownerUserId,
         replyMode,
         groupMode,
+        groupCommandMode,
+        groups,
         forwardThinking,
         forwardToolCalls,
         richInteractions,

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

@@ -0,0 +1,107 @@
+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 formatMentionedUserIds(turn) {
+    return turn.mentionedUserIds.length ? turn.mentionedUserIds.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 senderIsOwner = turn.senderIsOwner ?? formatSenderRelation(turn) === "owner";
+            return [
+                "[message]",
+                `sender_id: ${formatField(turn.senderId)}`,
+                `sender_name: ${formatField(senderName)}`,
+                `sender_profile_type: ${formatField(formatSenderProfileType(turn))}`,
+                `sender_is_owner: ${senderIsOwner ? "true" : "false"}`,
+                `mentions_current_agent: ${turn.wasMentioned ? "true" : "false"}`,
+                `mentioned_user_ids: ${formatField(formatMentionedUserIds(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))),
+        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;
+        },
+    };
+}