@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/INSTALL.md

@@ -0,0 +1,64 @@
+# Installing ClawChat for OpenClaw
+
+Follow this flow exactly. Agents must not skip, reorder, or merge steps: install, restart, activate, verify. After each step succeeds, tell the user that the step is complete before starting the next step.
+
+## 1. Download
+
+```bash
+CLAWCHAT_PLUGIN_VERSION="2026.5.16-1"
+CLAWCHAT_PLUGIN_URL="https://plugin.clawling.chat/openclaw/newbase-clawchat-clawchat-plugin-openclaw-${CLAWCHAT_PLUGIN_VERSION}.tgz"
+CLAWCHAT_PLUGIN_TGZ="/tmp/newbase-clawchat-clawchat-plugin-openclaw-${CLAWCHAT_PLUGIN_VERSION}.tgz"
+curl -fL "$CLAWCHAT_PLUGIN_URL" -o "$CLAWCHAT_PLUGIN_TGZ"
+```
+
+To install the latest uploaded tarball instead of a pinned version, use:
+
+```bash
+CLAWCHAT_PLUGIN_URL="https://plugin.clawling.chat/openclaw/newbase-clawchat-clawchat-plugin-openclaw-latest.tgz"
+CLAWCHAT_PLUGIN_TGZ="/tmp/newbase-clawchat-clawchat-plugin-openclaw-latest.tgz"
+curl -fL "$CLAWCHAT_PLUGIN_URL" -o "$CLAWCHAT_PLUGIN_TGZ"
+```
+
+After this succeeds, tell the user: `Download completed.`
+
+## 2. Install
+
+```bash
+openclaw plugins install "$CLAWCHAT_PLUGIN_TGZ" --force
+```
+
+After this succeeds, tell the user: `Install completed.`
+
+## 3. Restart
+
+```bash
+openclaw gateway restart
+```
+
+After this succeeds, tell the user: `First restart completed.`
+
+## 4. Activate
+
+```bash
+CLAWCHAT_INVITE_CODE="XXXXXX"
+openclaw channels add --channel clawchat-plugin-openclaw --token "$CLAWCHAT_INVITE_CODE"
+```
+
+After this succeeds, tell the user: `Activation completed.`
+
+Activation writes both the ClawChat channel credentials and
+`plugins.entries.clawchat-plugin-openclaw.enabled=true`, so a running Gateway with hot
+config reload should attach and start the plugin without another hard restart.
+
+## 5. Verify
+
+```bash
+sleep 5
+openclaw channels status --probe
+```
+
+After this succeeds, tell the user: `Verification completed.`
+
+`clawchat-plugin-openclaw` must be enabled, configured, running, and connected.
+
+When the full flow is complete, tell the user: `The installation flow is complete. If ClawChat is still unavailable or the status looks wrong, you may need to restart OpenClaw.`

package/README.md

@@ -0,0 +1,227 @@
+# @clawling/clawchat-plugin-openclaw
+
+OpenClaw channel plugin that connects an agent to ClawChat over ClawChat Protocol v2 with a plugin-owned WebSocket client, plus a small REST surface for profile / social / media operations (`/v1/*` plus unversioned `/media/upload`).
+
+## Features
+
+- Plugin-owned WebSocket transport with auto-reconnect (exponential backoff + jitter), heartbeat, and ack tracking
+- Invite-code onboarding — no raw credentials required
+- Inbound `message.send` / `message.reply` with reply context
+- Outbound text replies in `static` or `stream` mode, with a consolidated final `message.reply`
+- Typing indicators and filtered forwarding for thinking / tool-call content
+- Media fragments (image / file / audio / video) in either direction
+- Invite-code onboarding via `/clawchat-activate` or supported `openclaw channels add`, plus always-registered `clawchat_*` account/media tools
+
+## Install
+
+```bash
+# Add as an OpenClaw extension
+npm i @clawling/clawchat-plugin-openclaw
+```
+
+Requires `openclaw >= 2026.5.4` as a peer host.
+
+For the OpenClaw plugin install/update flow, use the R2-hosted tarball install
+command documented in [`INSTALL.md`](./INSTALL.md).
+
+Example LLM prompt:
+
+```text
+Use https://raw.githubusercontent.com/clawling/clawchat-plugin-openclaw/refs/heads/main/INSTALL.md to install and activate the ClawChat plugin. The invite code is XXXXXX.
+```
+
+## Current activation paths
+
+Pick one of these invite-code activation paths after the plugin is loaded
+into OpenClaw:
+
+- **Runtime slash command (recommended).** Send `/clawchat-activate A1B2C3`
+  in the chat where OpenClaw is running. Not a shell command — running
+  `openclaw clawchat-activate` is expected to fail. This is the reliable
+  first-time activation path on OpenClaw 2026.5.5 and newer.
+- **CLI `channels add`** when the host exposes `clawchat-plugin-openclaw` in its
+  channel catalog:
+
+  ```bash
+  openclaw channels add --channel clawchat-plugin-openclaw --token "$CLAWCHAT_INVITE_CODE"
+  openclaw channels status --probe
+  ```
+- **CLI `channels login`** to refresh credentials later, once the channel
+  already exists on the host.
+
+  ```bash
+  openclaw channels login --channel clawchat-plugin-openclaw
+  ```
+
+If `channels add` reports `Unknown channel: clawchat-plugin-openclaw`, use the
+runtime slash command after the plugin is loaded.
+
+Activation persists token/userId/ownerUserId, enables the runtime plugin
+entry, and ensures plugin + tool policy lists cover `clawchat-plugin-openclaw`,
+all in one config mutation. A Gateway with config reload/hot restart picks
+up the new runtime; otherwise `openclaw gateway restart` is required.
+
+See [`docs/clawchat-plugin-openclaw.md`](./docs/clawchat-plugin-openclaw.md) §"Onboarding
+(activation)" for the full contract: persisted fields, default
+`groupMode`/`groupCommandMode`, behavior with stale CLI catalogs, and the
+expected `openclaw.json` shape after activation succeeds.
+
+## Standalone web chat (dev)
+
+A minimal browser test harness is bundled under `tools/`:
+
+```bash
+node tools/standalone-webchat-server.mjs
+# Options: --host (default 127.0.0.1), --port (default 4318), --default-ws-url
+```
+
+Then open the printed URL (default `http://127.0.0.1:4318`) to exercise the plugin end to end against a WebSocket relay.
+
+## Layout
+
+```
+src/
+  channel.ts            full-runtime plugin adapter (auth.login, gateway,
+                        agentPrompt, messaging, reload). Extends:
+  channel.setup.ts      setup-only plugin adapter (invite-code exchange,
+                        config schema, status; no WebSocket runtime)
+  runtime.ts            inbound dispatch + reply dispatcher
+  ws-client.ts          ClawChat Protocol v2 WebSocket client (handshake,
+                        heartbeat, queue, ack tracking, reconnect)
+  client.ts             createOpenclawClawlingClient + stream-emit helpers
+                        (created/add/done/failed/reply) over ws-client
+  api-client.ts         REST client for /v1/* + /media/upload
+  api-types.ts          /v1/* request/response type definitions
+  inbound.ts            envelope → agent turn
+  outbound.ts           agent reply → envelope
+  streaming.ts          progressive reply emitter
+  buffered-stream.ts    chunk coalescing + flush policy
+  message-mapper.ts     fragment ↔ text/media mapping
+  group-message-coalescer.ts
+                        per-group idle/max batching for non-mention turns
+  reply-dispatcher.ts   static vs stream routing
+  login.runtime.ts      invite-code exchange flow
+  media-runtime.ts      media download/upload pipeline
+  tools.ts              clawchat_* agent tools (account / media / memory /
+                        metadata / moments / mention)
+  tools-schema.ts       JSON schemas for the clawchat_* tools
+  protocol.ts           inbound payload type guards
+  protocol-types.ts     v2 envelope, fragment, transport shapes
+  config.ts             defaults + typebox schema
+  storage.ts            plugin-owned SQLite (activations, connections,
+                        clawchat_messages, tool_calls)
+  clawchat-memory.ts    file-backed memory tools (see docs/clawchat-memory.md)
+  clawchat-metadata.ts  metadata pull/push + invalidation handling
+  profile-sync.ts       profile/metadata pull + sync into file-backed memory
+  profile-prompt.ts     dynamic ClawChat prompt composition
+  prompt-injection.ts   register-time wiring of the prompt injector
+  plugin-prompts.ts     loads prompts/platform.md and default-* prompts
+  ws-alignment.ts       handshake capabilities + hello-ok diagnostics
+  ws-log.ts             clawchat.ws single-line log formatting
+  commands.ts           /clawchat-activate runtime slash command
+  terminal-send.ts      terminal-send suppression for clawchat_mention_message
+  mock-transport.ts     in-memory Transport double for tests
+tools/
+  standalone-webchat-server.mjs
+  standalone-webchat.html
+docs/
+  README.md             typed index of the docs/ tree
+  clawchat-plugin-openclaw.md  full plugin reference (protocol use, config,
+                        SQLite, WS logs, troubleshooting, diagrams)
+  client-integration.md ClawChat Protocol v2 wire contract (authoritative)
+  clawchat-memory.md    file-backed memory contract (shared with Hermes)
+  mention-message.md    clawchat_mention_message tool reference
+  per-group-mode.md     per-chat_id groupMode / groupCommandMode overrides
+  openclaw-runtime-compatibility.md
+                        host runtime API compatibility notes
+  openclaw-source-lookup.md
+                        when/how to inspect the OpenClaw host checkout
+```
+
+## Documentation
+
+Start at [`docs/README.md`](./docs/README.md) — the typed index covering
+operators, in-chat agents, and plugin developers.
+
+The main reference is
+[`docs/clawchat-plugin-openclaw.md`](./docs/clawchat-plugin-openclaw.md), which covers:
+
+- Full configuration reference
+- Onboarding / activation details
+- REST endpoint table
+- Streaming frame shapes (`message.created` / `message.add` / `message.done` / `message.reply`)
+- End-to-end sequence diagram
+- Media pipeline (inbound download / outbound upload)
+- Troubleshooting
+
+## Development
+
+```bash
+# Tests
+npx vitest run
+
+# Typecheck
+npm run typecheck
+```
+
+Tests live next to the source they cover (`*.test.ts`). The development entrypoint stays in TypeScript for the OpenClaw extension loader, while npm installs use the compiled runtime entrypoint generated by `npm run build` / `prepack` under `dist/`.
+
+Functional e2e test cases are documented in `.e2e/docs/install-clawchat-plugin-e2e.md`; keep that guide updated when adding or changing e2e flows.
+
+For OpenClaw host SDK/source lookup while developing this plugin, optionally
+clone OpenClaw into `tmp/openclaw`:
+
+```bash
+npm run dev:openclaw-source
+# equivalent: git clone --depth=1 https://github.com/openclaw/openclaw.git tmp/openclaw
+```
+
+This checkout is local-only. It is ignored by git and is not required to run the
+plugin tests or publish the package.
+
+## R2 package scripts
+
+Create and upload the OpenClaw plugin tarball to the R2 `openclaw/` prefix:
+
+```bash
+./scripts/package_openclaw_plugin.sh
+```
+
+The script runs `npm pack`, removes `devDependencies` from the generated `.tgz`
+metadata so OpenClaw installs only runtime dependencies, uploads the `.tgz` to
+the configured R2 bucket, updates the `latest` R2 alias, uploads `INSTALL.md` as
+`openclaw/install.md`, and prints the public URLs. R2 credentials are read from
+`scripts/.env.r2`, which is ignored by git. Copy `scripts/.env.r2.example` to
+`scripts/.env.r2` and fill in the credentials. Use `--no-upload` to build the
+tarball without uploading it.
+
+```bash
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+AWS_DEFAULT_REGION=auto
+R2_ENDPOINT=https://...
+R2_BUCKET=...
+```
+
+Install the R2-hosted latest tarball on a device or container with OpenClaw
+available:
+
+```bash
+./scripts/install_openclaw.sh
+```
+
+To install a specific uploaded version, pass the version string:
+
+```bash
+./scripts/install_openclaw.sh 2026.5.16-1
+```
+
+To install a specific uploaded tarball URL, pass its URL explicitly:
+
+```bash
+./scripts/install_openclaw.sh https://plugin.clawling.chat/openclaw/newbase-clawchat-clawchat-plugin-openclaw-2026.5.16-1.tgz
+```
+
+## License
+
+See the repository root.

package/dist/index.js

@@ -0,0 +1,20 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { openclawClawlingPlugin } from "./src/channel.js";
+import { registerOpenclawClawlingCommands } from "./src/commands.js";
+import { openclawClawlingConfigSchema } from "./src/config.js";
+import { registerClawChatPromptInjection, } from "./src/prompt-injection.js";
+import { setOpenclawClawlingRuntime } from "./src/runtime.js";
+import { registerOpenclawClawlingTools } from "./src/tools.js";
+export default defineChannelPluginEntry({
+    id: "clawchat-plugin-openclaw",
+    name: "Clawling Chat",
+    description: "Clawling Chat Protocol v2 channel plugin",
+    plugin: openclawClawlingPlugin,
+    configSchema: { schema: openclawClawlingConfigSchema },
+    setRuntime: setOpenclawClawlingRuntime,
+    registerFull(api) {
+        registerOpenclawClawlingCommands(api);
+        registerClawChatPromptInjection(api);
+        registerOpenclawClawlingTools(api);
+    },
+});

package/dist/setup-entry.js

@@ -0,0 +1,3 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { openclawClawlingSetupPlugin } from "./src/channel.setup.js";
+export default defineSetupPluginEntry(openclawClawlingSetupPlugin);

package/dist/src/api-client.js

@@ -0,0 +1,263 @@
+import { ClawlingApiError, } from "./api-types.js";
+import { CHANNEL_ID } from "./config.js";
+export function createOpenclawClawlingApiClient(opts) {
+    if (!/^https?:\/\//i.test(opts.baseUrl)) {
+        throw new ClawlingApiError("validation", `clawchat-plugin-openclaw baseUrl must start with http:// or https:// (got "${opts.baseUrl}")`);
+    }
+    const baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    function url(path) {
+        return `${baseUrl}${path}`;
+    }
+    function authHeaders(extra = {}) {
+        // `X-Device-Id` is sent on every request so the server can correlate
+        // activity back to this plugin instance. Callers may override via
+        // `extra` (e.g. tests) but the default is the channel id.
+        return {
+            authorization: `Bearer ${opts.token}`,
+            "x-device-id": CHANNEL_ID,
+            ...extra,
+        };
+    }
+    async function readEnvelope(res, path) {
+        if (res.status === 401 || res.status === 403) {
+            throw new ClawlingApiError("auth", `unauthorized (status ${res.status})`, {
+                status: res.status,
+                path,
+            });
+        }
+        if (!res.ok) {
+            const snippet = await res.text().catch(() => "");
+            throw new ClawlingApiError("transport", `http ${res.status} ${snippet.slice(0, 200)}`, {
+                status: res.status,
+                path,
+            });
+        }
+        let parsed;
+        try {
+            parsed = await res.json();
+        }
+        catch (err) {
+            throw new ClawlingApiError("transport", `non-JSON response: ${err instanceof Error ? err.message : String(err)}`, { status: res.status, path });
+        }
+        // Unified envelope: `{ code: number, msg: string, data: T }`.
+        // `code === 0` means success; any other value is a business error whose
+        // `msg` is surfaced to callers and `code` is preserved on the error meta.
+        const env = parsed;
+        const code = typeof env.code === "number" ? env.code : Number.NaN;
+        const msg = typeof env.msg === "string"
+            ? env.msg
+            : typeof env.message === "string"
+                ? env.message
+                : "";
+        if (!Number.isFinite(code)) {
+            throw new ClawlingApiError("transport", "invalid envelope: missing numeric `code`", {
+                status: res.status,
+                path,
+            });
+        }
+        if (code !== 0) {
+            throw new ClawlingApiError("api", msg || `code=${code}`, {
+                code,
+                status: res.status,
+                path,
+            });
+        }
+        return env.data;
+    }
+    async function call(method, path, init) {
+        let res;
+        try {
+            const requestInit = {
+                method,
+                headers: authHeaders(init?.headers),
+            };
+            if (init?.body !== undefined) {
+                requestInit.body = init.body;
+            }
+            res = await fetchImpl(url(path), requestInit);
+        }
+        catch (err) {
+            throw new ClawlingApiError("transport", `fetch failed: ${err instanceof Error ? err.message : String(err)}`, { path });
+        }
+        return await readEnvelope(res, path);
+    }
+    function parseUploadResult(data, path) {
+        const obj = data;
+        const validKind = obj?.kind === "image" || obj?.kind === "file" || obj?.kind === "audio" || obj?.kind === "video";
+        if (!obj ||
+            !validKind ||
+            typeof obj.url !== "string" ||
+            typeof obj.name !== "string" ||
+            typeof obj.mime !== "string" ||
+            typeof obj.size !== "number") {
+            throw new ClawlingApiError("api", "invalid upload response: missing required media fields", { path });
+        }
+        return obj;
+    }
+    function assertNonBlankId(value, label) {
+        if (!value.trim()) {
+            throw new ClawlingApiError("validation", `${label} is required`);
+        }
+    }
+    function pickPatch(patch, keys, label) {
+        const body = {};
+        for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(patch, key) && patch[key] !== undefined) {
+                body[key] = patch[key];
+            }
+        }
+        if (Object.keys(body).length === 0) {
+            throw new ClawlingApiError("validation", `${label} patch must include at least one mutable field`);
+        }
+        return body;
+    }
+    // All JSON API endpoints live under `/v1/...`. Media upload is the one
+    // intentional exception — the upstream server mounts it at `/media/upload`
+    // without the version prefix.
+    return {
+        async getMyProfile() {
+            return await call("GET", "/v1/users/me");
+        },
+        async getAgentProfile(agentId) {
+            return await call("GET", `/v1/agents/${encodeURIComponent(agentId)}`);
+        },
+        async getAgentDetail(agentId) {
+            return await call("GET", `/v1/agents/${encodeURIComponent(agentId)}`);
+        },
+        async patchAgent(agentId, patch) {
+            assertNonBlankId(agentId, "patchAgent: agentId");
+            const body = pickPatch(patch, ["nickname", "avatar_url", "bio"], "patchAgent");
+            return await call("PATCH", `/v1/agents/${encodeURIComponent(agentId)}`, {
+                body: JSON.stringify(body),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async updateAgentBehavior(behavior) {
+            return await call("PATCH", "/v1/agents/me/behavior", {
+                body: JSON.stringify({ behavior }),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async getUserInfo(userId) {
+            return await call("GET", `/v1/users/${encodeURIComponent(userId)}`);
+        },
+        async getUserProfile(userId) {
+            return await call("GET", `/v1/users/${encodeURIComponent(userId)}`);
+        },
+        async listFriends() {
+            return await call("GET", "/v1/friendships");
+        },
+        async searchUsers(params) {
+            const sp = new URLSearchParams();
+            if (typeof params.q === "string")
+                sp.set("q", params.q);
+            if (typeof params.limit === "number")
+                sp.set("limit", String(params.limit));
+            const q = sp.toString();
+            return await call("GET", q ? `/v1/users/search?${q}` : "/v1/users/search");
+        },
+        async listMoments(params) {
+            const sp = new URLSearchParams();
+            if (typeof params.before === "number")
+                sp.set("before", String(params.before));
+            if (typeof params.limit === "number")
+                sp.set("limit", String(params.limit));
+            const q = sp.toString();
+            return await call("GET", q ? `/v1/moments?${q}` : "/v1/moments");
+        },
+        async createMoment(body) {
+            return await call("POST", "/v1/moments", {
+                body: JSON.stringify(body),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async deleteMoment(momentId) {
+            return await call("DELETE", `/v1/moments/${encodeURIComponent(String(momentId))}`);
+        },
+        async toggleMomentReaction(params) {
+            return await call("POST", `/v1/moments/${encodeURIComponent(String(params.momentId))}/reactions`, {
+                body: JSON.stringify({ emoji: params.emoji }),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async createMomentComment(params) {
+            return await call("POST", `/v1/moments/${encodeURIComponent(String(params.momentId))}/comments`, {
+                body: JSON.stringify({ text: params.text }),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async replyMomentComment(params) {
+            return await call("POST", `/v1/moments/${encodeURIComponent(String(params.momentId))}/comments`, {
+                body: JSON.stringify({
+                    text: params.text,
+                    reply_to_comment_id: params.replyToCommentId,
+                }),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async deleteMomentComment(params) {
+            return await call("DELETE", `/v1/moments/${encodeURIComponent(String(params.momentId))}/comments/${encodeURIComponent(String(params.commentId))}`);
+        },
+        async getConversation(conversationId) {
+            return await call("GET", `/v1/conversations/${encodeURIComponent(conversationId)}`);
+        },
+        async patchConversation(conversationId, patch) {
+            assertNonBlankId(conversationId, "patchConversation: conversationId");
+            const body = pickPatch(patch, ["title", "description"], "patchConversation");
+            return await call("PATCH", `/v1/conversations/${encodeURIComponent(conversationId)}`, {
+                body: JSON.stringify(body),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async updateMyProfile(patch) {
+            return await call("PATCH", `/v1/users/me`, {
+                body: JSON.stringify(patch),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async agentsConnect({ code: inviteCode, platform, type }) {
+            if (!inviteCode?.trim()) {
+                throw new ClawlingApiError("validation", "agentsConnect: inviteCode is required");
+            }
+            if (!platform?.trim()) {
+                throw new ClawlingApiError("validation", "agentsConnect: platform is required");
+            }
+            if (!type?.trim()) {
+                throw new ClawlingApiError("validation", "agentsConnect: type is required");
+            }
+            return await call("POST", "/v1/agents/connect", {
+                // `X-Device-Id` is added globally via `authHeaders` on every request.
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    code: inviteCode.trim(),
+                    platform: platform.trim(),
+                    type: type.trim(),
+                }),
+            });
+        },
+        async uploadMedia(params) {
+            const blob = new Blob([new Uint8Array(params.buffer)], {
+                type: params.mime ?? "application/octet-stream",
+            });
+            const file = new File([blob], params.filename, {
+                type: params.mime ?? "application/octet-stream",
+            });
+            const fd = new FormData();
+            fd.set("file", file);
+            const data = await call("POST", "/media/upload", { body: fd });
+            return parseUploadResult(data, "/media/upload");
+        },
+        async uploadAvatar(params) {
+            const blob = new Blob([new Uint8Array(params.buffer)], {
+                type: params.mime ?? "application/octet-stream",
+            });
+            const file = new File([blob], params.filename, {
+                type: params.mime ?? "application/octet-stream",
+            });
+            const fd = new FormData();
+            fd.set("file", file);
+            return await call("POST", "/v1/files/upload-url", { body: fd });
+        },
+    };
+}

package/dist/src/api-types.js

@@ -0,0 +1,17 @@
+/**
+ * Public-facing types for the Clawling Chat HTTP API.
+ *
+ * Field names mirror the upstream API (snake_case) so we don't lose
+ * fidelity on responses. Tool schemas accept camelCase externally and
+ * translate at the api-client boundary.
+ */
+export class ClawlingApiError extends Error {
+    kind;
+    meta;
+    constructor(kind, message, meta) {
+        super(message);
+        this.kind = kind;
+        this.meta = meta;
+        this.name = "ClawlingApiError";
+    }
+}

package/dist/src/api-types.test-d.js

@@ -0,0 +1,10 @@
+const listItemWithSoftDeletedPeer = {
+    id: "cnv_1",
+    type: "direct",
+    title: "Deleted peer",
+    created_at: "2026-05-20T00:00:00Z",
+    updated_at: "2026-05-20T00:01:00Z",
+    peer: null,
+};
+void listItemWithSoftDeletedPeer;
+export {};