@clawling/clawchat-plugin-openclaw 2026.8.27-2 → 2026.9.1-1

package/dist/src/friend-request-turn.js

@@ -0,0 +1,83 @@
+/**
+ * Synthetic reasoning-turn builder for `friend.request` notify.signal events.
+ *
+ * When the server fires a `friend.request` signal the runtime dispatches one
+ * deduped synthetic `message.send` envelope so the agent can reason about the
+ * pending request. The prompt text varies by the current "friend.add" permission
+ * policy state: a deny policy yields a decline/inform prompt; ask or allow
+ * yields a prompt that instructs the agent to review the request via the
+ * `clawchat_list_friend_requests` tool.
+ */
+import { EVENT } from "./protocol-types.js";
+/**
+ * Returns canned prompt text for a friend-request reasoning turn based on the
+ * current "friend.add" permission policy state.
+ *
+ * - `deny`  → inform the agent it should decline; no accept instruction.
+ * - `ask` / `allow` → instruct the agent to review the pending request.
+ *
+ * The requester's user id is embedded so the agent does not go looking up the
+ * synthetic sender ("clawchat-friend-request" is not a real user).
+ */
+export function friendRequestPromptFor(state, requesterUserId) {
+    const arrived = requesterUserId
+        ? `A new friend request has arrived from user ${requesterUserId}.`
+        : "A new friend request has arrived.";
+    if (state === "deny") {
+        return [
+            arrived,
+            "Your current friend-add policy is set to deny.",
+            "Do not add this contact.",
+            "You may inform the requester that you cannot add them at this time.",
+        ].join(" ");
+    }
+    return [
+        arrived,
+        "Please review the pending request by calling `clawchat_list_friend_requests`",
+        "and decide whether to accept it.",
+    ].join(" ");
+}
+/**
+ * Builds a synthetic `message.send` envelope that triggers one agent reasoning
+ * turn for a pending friend request. The envelope shape mirrors the
+ * activation-bootstrap envelope; it targets the owner's direct conversation so
+ * the agent has context about who it is reasoning for.
+ */
+export function buildFriendRequestEnvelope(params) {
+    const { account, state, entityId, ownerConversationId } = params;
+    const text = friendRequestPromptFor(state, entityId);
+    const now = Date.now();
+    // Fall back to ownerUserId only when no activation conversation is recorded:
+    // the turn still runs (the agent can act via tools, e.g. accept the request),
+    // but its in-chat replies will not be deliverable until activation records
+    // the owner conversation.
+    return {
+        version: "2",
+        event: EVENT.MESSAGE_SEND,
+        trace_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+        emitted_at: now,
+        chat_id: ownerConversationId ?? account.ownerUserId,
+        chat_type: "direct",
+        to: { id: account.userId, type: "direct" },
+        sender: {
+            id: "clawchat-friend-request",
+            type: "direct",
+            nick_name: "ClawChat",
+        },
+        payload: {
+            message_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+            message_mode: "normal",
+            message: {
+                body: { fragments: [{ kind: "text", text }] },
+                context: { mentions: [], reply: null },
+                streaming: {
+                    status: "static",
+                    sequence: 0,
+                    mutation_policy: "sealed",
+                    started_at: null,
+                    completed_at: null,
+                },
+            },
+        },
+    };
+}

package/dist/src/runtime.js

@@ -2352,7 +2352,6 @@ export async function startOpenclawClawlingGateway(params) {
     };
     const dispatchTurnToAgent = async (turn) => {
         const rt = runtime.channel;
-        const storePath = rt.session.resolveStorePath(cfg.session?.store);
         const routeCfg = withClawChatSessionScope(cfg);
         const route = rt.routing.resolveAgentRoute({
             cfg: routeCfg,
@@ -2360,6 +2359,13 @@ export async function startOpenclawClawlingGateway(params) {
             accountId,
             peer: turn.peer,
         });
+        // OpenClaw >=2026.8 (roster-only refactor, openclaw#112678) throws
+        // SessionStoreAgentIdRequiredError when `session.store` is unset and no agentId is
+        // supplied — that killed every inbound turn. Older hosts already accepted
+        // `opts.agentId` and merely defaulted it to "main", so passing the routed id is
+        // correct on the whole supported range and resolves to the same path for a
+        // single-agent roster. Must stay below resolveAgentRoute: it owns `agentId`.
+        const storePath = rt.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
         const memoryRoot = resolveClawChatMemoryRoot(runtime, cfg, route.agentId);
         const body = rt.reply.formatAgentEnvelope({
             channel: "Clawling Chat",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.8.27-2",
+  "version": "2026.9.1-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/runtime.ts

@@ -2818,7 +2818,6 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
 
   const dispatchTurnToAgent = async (turn: IngestTurnParams): Promise<IngestTurnResult> => {
     const rt = runtime.channel;
-    const storePath = rt.session.resolveStorePath(cfg.session?.store);
     const routeCfg = withClawChatSessionScope(cfg);
     const route = rt.routing.resolveAgentRoute({
       cfg: routeCfg,
@@ -2826,6 +2825,13 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       accountId,
       peer: turn.peer,
     });
+    // OpenClaw >=2026.8 (roster-only refactor, openclaw#112678) throws
+    // SessionStoreAgentIdRequiredError when `session.store` is unset and no agentId is
+    // supplied — that killed every inbound turn. Older hosts already accepted
+    // `opts.agentId` and merely defaulted it to "main", so passing the routed id is
+    // correct on the whole supported range and resolves to the same path for a
+    // single-agent roster. Must stay below resolveAgentRoute: it owns `agentId`.
+    const storePath = rt.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
     const memoryRoot = resolveClawChatMemoryRoot(runtime, cfg, route.agentId);
     const body = rt.reply.formatAgentEnvelope({
       channel: "Clawling Chat",