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

package/dist/src/profile-prompt.js

@@ -0,0 +1,150 @@
+import { readClawChatMemoryFile } from "./clawchat-memory.js";
+export const CLAWCHAT_SILENT_RESPONSE = "<clawchat:silent/>";
+export const CLAWCHAT_EMPTY_RESPONSE = '""';
+const GROUP_BATCH_REPLY_GUIDANCE = 'Hard no-reply rules: if mentioned_user_ids is not "-" and mentions_current_agent is false, return exactly "" and nothing else. ' +
+    'If the input is unrelated to ClawChat Agent Behavior, return exactly "" and nothing else. These rules override sender_is_owner, ' +
+    "group usefulness, and general helpfulness. Reply only if mentions_current_agent is true, or there is no mention and the text " +
+    'explicitly asks this agent to participate. Otherwise return exactly "" and nothing else.';
+const GROUP_BATCH_MENTION_REPLY_GUIDANCE = "You were directly addressed in this group batch. Reply by default, including when the message contains only a mention. " +
+    "Stay silent only if the group profile/regulation explicitly forbids replying.";
+export function isClawChatNoopResponseText(value) {
+    const text = value.trim();
+    return text === CLAWCHAT_EMPTY_RESPONSE;
+}
+export function resolveSenderRelation(params) {
+    if (params.senderId === params.accountUserId)
+        return "self_agent";
+    if (params.senderId === params.accountOwnerUserId)
+        return "owner";
+    if (params.senderProfileType === "agent")
+        return "peer_agent";
+    return "peer_user";
+}
+function formatValue(value) {
+    if (value == null)
+        return "null";
+    if (typeof value !== "string")
+        return String(value);
+    return value.replace(/[\\\r\n\u2028\u2029\u0000-\u001f\u007f-\u009f]/g, (char) => {
+        if (char === "\\")
+            return "\\\\";
+        if (char === "\r")
+            return "\\r";
+        if (char === "\n")
+            return "\\n";
+        return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+    });
+}
+function renderFields(fields) {
+    return fields.map(([name, value]) => `${name}: ${formatValue(value)}`).join("\n");
+}
+function renderMetadataFields(metadata) {
+    return Object.entries(metadata).map(([name, value]) => `${name}: ${formatValue(value)}`).join("\n");
+}
+function renderProfileSection(title, fields) {
+    return `## ${title}\n${renderFields(fields)}`;
+}
+function renderMetadataSection(title, metadata) {
+    return `## ${title}\n${renderMetadataFields(metadata)}`;
+}
+function renderResponseProtocol(turn) {
+    const wasMentioned = turn.wasMentioned ?? false;
+    const replyGuidance = turn.chatType === "group"
+        ? wasMentioned
+            ? GROUP_BATCH_MENTION_REPLY_GUIDANCE
+            : GROUP_BATCH_REPLY_GUIDANCE
+        : "Direct messages are normally addressed to you. Reply unless the agent behavior says this message should not be answered.";
+    return renderProfileSection("ClawChat Response Protocol", [
+        [
+            "response_decision",
+            turn.chatType === "group"
+                ? "Decide whether this group input needs a reply from you."
+                : "Decide whether this direct message needs a reply from you.",
+        ],
+        ["allowed_outputs", "normal_reply OR exact_empty_response"],
+        ["exact_empty_response", CLAWCHAT_EMPTY_RESPONSE],
+        ["reply_guidance", replyGuidance],
+        ["no_reply_protocol", 'If you choose not to reply, return exactly "" and nothing else.'],
+    ]);
+}
+export function renderClawChatProfilePrompt(params) {
+    const sections = [params.basePrompt.trim()];
+    if (params.ownerMetadata && Object.keys(params.ownerMetadata).length > 0) {
+        sections.push(renderMetadataSection("Current ClawChat Owner Metadata", params.ownerMetadata));
+    }
+    if (params.turn.chatType === "dm" &&
+        !params.turn.senderIsOwner &&
+        params.userMetadata &&
+        Object.keys(params.userMetadata).length > 0) {
+        sections.push(renderMetadataSection("Current ClawChat User Metadata", params.userMetadata));
+    }
+    if (params.turn.chatType === "group" &&
+        params.groupMetadata &&
+        Object.keys(params.groupMetadata).length > 0) {
+        sections.push(renderMetadataSection("Current ClawChat Group Metadata", params.groupMetadata));
+    }
+    if (params.turn.chatType === "group") {
+        const wasMentioned = params.turn.wasMentioned ?? false;
+        sections.push(renderProfileSection("Current ClawChat Message Metadata", [
+            ["chat_type", params.turn.chatType],
+            ["group_id", params.turn.groupId],
+        ]));
+    }
+    else {
+        sections.push(renderProfileSection("Current ClawChat Message Metadata", [
+            ["chat_type", params.turn.chatType],
+            ["sender_id", params.turn.senderId],
+            ["sender_name", params.turn.senderName],
+            ["sender_profile_type", params.turn.senderProfileType],
+            ["sender_is_owner", params.turn.senderIsOwner],
+        ]));
+    }
+    sections.push(renderResponseProtocol(params.turn));
+    return sections.filter(Boolean).join("\n\n");
+}
+function hasBrokenMetadataBlock(raw) {
+    const start = "<!-- clawchat:metadata:start -->";
+    const end = "<!-- clawchat:metadata:end -->";
+    return raw.startsWith(start) && !raw.includes(end);
+}
+async function loadMetadataFile(params) {
+    try {
+        const file = await readClawChatMemoryFile(params.memoryRoot, params.target);
+        if (!file.exists)
+            return null;
+        if (hasBrokenMetadataBlock(file.raw)) {
+            params.log?.error?.(`openclaw-clawchat: skipping broken ${params.label} metadata block`);
+            return null;
+        }
+        return Object.keys(file.metadata).length > 0 ? file.metadata : null;
+    }
+    catch (err) {
+        params.log?.error?.(`openclaw-clawchat: failed to read ${params.label} metadata block: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+export async function loadClawChatPromptMetadata(params) {
+    const ownerMetadata = await loadMetadataFile({
+        memoryRoot: params.memoryRoot,
+        target: { targetType: "owner", targetId: "owner" },
+        label: "owner",
+        log: params.log,
+    });
+    const userMetadata = params.turn.chatType === "dm" && !params.turn.senderIsOwner
+        ? await loadMetadataFile({
+            memoryRoot: params.memoryRoot,
+            target: { targetType: "user", targetId: params.turn.senderId },
+            label: "user",
+            log: params.log,
+        })
+        : null;
+    const groupMetadata = params.turn.chatType === "group" && params.turn.groupId
+        ? await loadMetadataFile({
+            memoryRoot: params.memoryRoot,
+            target: { targetType: "group", targetId: params.turn.groupId },
+            label: "group",
+            log: params.log,
+        })
+        : null;
+    return { ownerMetadata, userMetadata, groupMetadata };
+}

package/dist/src/profile-sync.js

@@ -0,0 +1,169 @@
+import { pullGroupMetadata, pullOwnerMetadata, pullUserMetadata, } from "./clawchat-metadata.js";
+function parseApiTimestamp(value) {
+    if (typeof value !== "string")
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function buildConversationDetailsCacheInput(params) {
+    const refreshedAt = Date.now();
+    const participants = Array.isArray(params.conversation.participants)
+        ? params.conversation.participants
+        : [];
+    return {
+        platform: params.platform,
+        accountId: params.accountId,
+        conversationId: params.conversation.id,
+        conversationType: params.conversation.type,
+        lastSeenAt: parseApiTimestamp(params.conversation.updated_at),
+        lastRefreshedAt: refreshedAt,
+        members: participants.map((participant) => ({
+            userId: participant.user_id,
+            role: participant.role,
+            lastSeenAt: parseApiTimestamp(participant.joined_at),
+        })),
+        membersComplete: true,
+    };
+}
+function requireMemoryRoot(memoryRoot, log, label) {
+    if (typeof memoryRoot === "string" && memoryRoot.trim())
+        return true;
+    log?.error?.(`openclaw-clawchat ${label} metadata refresh requires memoryRoot`);
+    return false;
+}
+export async function ensureUserProfileForSender(params) {
+    void params.accountUserId;
+    void params.accountOwnerUserId;
+    void params.lastSeenAt;
+    void params.sender.nickname;
+    if (!requireMemoryRoot(params.memoryRoot, params.log, "user"))
+        return;
+    try {
+        await pullUserMetadata({
+            memoryRoot: params.memoryRoot,
+            userId: params.sender.id,
+            api: params.api,
+        });
+    }
+    catch (err) {
+        params.log?.error?.(`openclaw-clawchat first-seen user metadata refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export async function refreshGroupProfile(params) {
+    const conversationId = params.conversationId ?? params.chatId ?? "";
+    if (!conversationId || !params.api.getConversation)
+        return false;
+    try {
+        let conversation;
+        if (requireMemoryRoot(params.memoryRoot, params.log, "group")) {
+            const result = await pullGroupMetadata({
+                memoryRoot: params.memoryRoot,
+                groupId: conversationId,
+                api: params.api,
+            });
+            if (result.failures.length > 0) {
+                params.log?.error?.(`openclaw-clawchat group participant metadata refresh partially failed: ${result.failures.map((failure) => `${failure.targetId}: ${failure.error}`).join("; ")}`);
+            }
+            if (!result.conversation)
+                return false;
+            conversation = result.conversation;
+        }
+        else {
+            const data = await params.api.getConversation(conversationId);
+            conversation = data.conversation;
+        }
+        params.store.upsertConversationDetails?.({
+            ...buildConversationDetailsCacheInput({
+                platform: params.platform,
+                accountId: params.accountId,
+                conversation,
+            }),
+        });
+        return true;
+    }
+    catch (err) {
+        params.log?.error?.(`openclaw-clawchat group metadata refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+export async function ensureGroupProfileForChat(params) {
+    if (params.chat.type !== "group")
+        return false;
+    return await refreshGroupProfile({
+        platform: params.platform,
+        accountId: params.accountId,
+        conversationId: params.chat.id,
+        api: params.api,
+        store: params.store,
+        memoryRoot: params.memoryRoot,
+        log: params.log,
+    });
+}
+export async function refreshAgentBehaviorProfile(params) {
+    if (!requireMemoryRoot(params.memoryRoot, params.log, "owner"))
+        return;
+    try {
+        await pullOwnerMetadata({
+            memoryRoot: params.memoryRoot,
+            agentId: params.agentId ?? "",
+            accountUserId: params.accountUserId,
+            accountOwnerUserId: params.accountOwnerUserId,
+            api: params.api,
+        });
+    }
+    catch (err) {
+        params.log?.error?.(`openclaw-clawchat owner metadata refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export async function syncFirstSeenClawChatProfiles(params) {
+    const { platform, accountId, accountUserId, accountOwnerUserId, chat, sender, api, store } = params;
+    const cachedConversation = store.getCachedConversation?.({
+        platform,
+        accountId,
+        conversationId: chat.id,
+    });
+    const isNewChat = !cachedConversation;
+    if (isNewChat) {
+        store.upsertConversationSummary?.({
+            platform,
+            accountId,
+            conversationId: chat.id,
+            conversationType: chat.type,
+            lastSeenAt: chat.lastSeenAt ?? null,
+        });
+    }
+    const refreshedGroupDetails = await ensureGroupProfileForChat({
+        platform,
+        accountId,
+        chat,
+        api,
+        store,
+        memoryRoot: params.memoryRoot,
+        log: params.log,
+    });
+    await ensureUserProfileForSender({
+        platform,
+        accountId,
+        accountUserId,
+        accountOwnerUserId,
+        sender,
+        lastSeenAt: chat.lastSeenAt ?? null,
+        api,
+        store,
+        memoryRoot: params.memoryRoot,
+        log: params.log,
+    });
+    if (isNewChat && chat.type === "group" && !refreshedGroupDetails && api.getConversation && store.upsertConversationDetails) {
+        try {
+            const data = await api.getConversation(chat.id);
+            store.upsertConversationDetails(buildConversationDetailsCacheInput({
+                platform,
+                accountId,
+                conversation: data.conversation,
+            }));
+        }
+        catch (err) {
+            params.log?.error?.(`openclaw-clawchat first-seen conversation detail refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/src/prompt-injection.js

@@ -0,0 +1,25 @@
+const promptInjectionsBySessionKey = new Map();
+export function clearClawChatPromptInjections() {
+    promptInjectionsBySessionKey.clear();
+}
+export function clearClawChatPromptInjectionForSession(sessionKey) {
+    promptInjectionsBySessionKey.delete(sessionKey);
+}
+export function stageClawChatPromptInjection(params) {
+    promptInjectionsBySessionKey.set(params.sessionKey, params.prompt);
+}
+export function renderClawChatPromptInjectionForSession(sessionKey) {
+    return promptInjectionsBySessionKey.get(sessionKey);
+}
+export function registerClawChatPromptInjection(api) {
+    api.on("before_prompt_build", async (_event, ctx) => {
+        const sessionKey = ctx.sessionKey;
+        if (!sessionKey)
+            return undefined;
+        const prompt = promptInjectionsBySessionKey.get(sessionKey);
+        if (!prompt)
+            return undefined;
+        promptInjectionsBySessionKey.delete(sessionKey);
+        return { appendSystemContext: prompt };
+    }, { priority: 100 });
+}

package/dist/src/protocol-types.js

@@ -0,0 +1,63 @@
+export const EVENT = {
+    CONNECT_CHALLENGE: "connect.challenge",
+    CONNECT: "connect",
+    HELLO_OK: "hello-ok",
+    HELLO_FAIL: "hello-fail",
+    MESSAGE_SEND: "message.send",
+    MESSAGE_ACK: "message.ack",
+    MESSAGE_ERROR: "message.error",
+    MESSAGE_REPLY: "message.reply",
+    MESSAGE_CREATED: "message.created",
+    MESSAGE_ADD: "message.add",
+    MESSAGE_DONE: "message.done",
+    MESSAGE_FAILED: "message.failed",
+    TYPING_UPDATE: "typing.update",
+    CHAT_METADATA_INVALIDATED: "chat.metadata.invalidated",
+    OFFLINE_BATCH: "offline.batch",
+    OFFLINE_ACK: "offline.ack",
+    OFFLINE_DONE: "offline.done",
+    PING: "ping",
+    PONG: "pong",
+};
+export class AuthError extends Error {
+    name = "AuthError";
+}
+export class TransportError extends Error {
+    name = "TransportError";
+}
+export class ProtocolError extends Error {
+    envelope;
+    name = "ProtocolError";
+    constructor(message, envelope) {
+        super(message);
+        this.envelope = envelope;
+    }
+}
+export class AckTimeoutError extends Error {
+    traceId;
+    timeoutMs;
+    name = "AckTimeoutError";
+    constructor(traceId, timeoutMs) {
+        super(`ack timeout after ${timeoutMs}ms for trace_id=${traceId}`);
+        this.traceId = traceId;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class MessageSendError extends Error {
+    traceId;
+    code;
+    chatId;
+    name = "MessageSendError";
+    constructor(traceId, code, message, chatId) {
+        super(`message.error ${code}: ${message} for trace_id=${traceId}`);
+        this.traceId = traceId;
+        this.code = code;
+        this.chatId = chatId;
+    }
+}
+export class StateError extends Error {
+    name = "StateError";
+}
+export function isBusinessDispatchEvent(event) {
+    return event === EVENT.MESSAGE_SEND || event === EVENT.MESSAGE_REPLY || event === EVENT.MESSAGE_DONE;
+}

package/dist/src/protocol-types.typecheck.js

@@ -0,0 +1 @@
+export {};

package/dist/src/protocol.js

@@ -1,8 +1,8 @@
 /**
  * Local narrow guards for inbound protocol envelopes.
  *
- * The SDK's `message` event hands us `Envelope<unknown>`. Before casting the
- * payload to `DownlinkMessageSendPayload` we run these cheap structural checks
+ * Raw client events hand us `Envelope<unknown>`. Before casting the
+ * payload to `MessagePayload` we run these cheap structural checks
  * so runtime errors surface as skipped messages, not crashes.
  */
 export function isInboundMessagePayload(payload) {