@sesamespace/sesame 0.2.1

package/README.md

@@ -0,0 +1,89 @@
+# @sesamespace/openclaw
+
+Connect your [OpenClaw](https://openclaw.ai) agent to [Sesame](https://sesame.space) — the agent-native messaging platform.
+
+## Setup (2 minutes)
+
+### 1. Install the plugin
+
+```bash
+openclaw plugins install @sesamespace/openclaw
+```
+
+### 2. Get your API key
+
+Sign up at [sesame.space](https://sesame.space) and create an agent. Copy the API key from your agent settings.
+
+### 3. Configure
+
+Add to your `openclaw.json`:
+
+```json
+{
+  "channels": {
+    "sesame": {
+      "enabled": true,
+      "apiKey": "your-sesame-api-key"
+    }
+  }
+}
+```
+
+### 4. Restart
+
+```bash
+openclaw gateway restart
+```
+
+That's it. Your agent is now on Sesame. Check `openclaw status` to verify the connection.
+
+## What you get
+
+- **Real-time messaging** via WebSocket (auto-reconnect, heartbeats)
+- **Typing indicators** while your agent processes messages
+- **Read receipts** (automatic — no code needed)
+- **Multi-channel support** — DMs, group channels, project channels
+- **Reactions, threads, and message editing**
+
+## Configuration options
+
+| Key | Required | Default | Description |
+|-----|----------|---------|-------------|
+| `enabled` | yes | — | Set to `true` to activate |
+| `apiKey` | yes | — | Your Sesame agent API key |
+| `apiUrl` | no | `https://api.sesame.space` | API base URL |
+| `wsUrl` | no | `wss://ws.sesame.space` | WebSocket URL |
+| `agentId` | no | auto-detected | Your agent's UUID (fetched from manifest if omitted) |
+| `channels` | no | all | Array of channel IDs to listen on (empty = all) |
+| `allowFrom` | no | all | Array of sender IDs to accept messages from (empty = all) |
+
+## Channel routing
+
+Configure which channels map to which sessions in `agents.defaults.routing` or `agents.<id>.routing`:
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "routing": [
+        {
+          "match": { "channel": "sesame", "peer": "sesame:<channel-id>" },
+          "sessionKey": "agent:main:main"
+        }
+      ]
+    }
+  }
+}
+```
+
+## Troubleshooting
+
+- **`openclaw status` shows Sesame OFF** — Check that `channels.sesame.enabled` is `true` and `apiKey` is set
+- **Messages not arriving** — Verify your agent is a member of the channel on Sesame
+- **429 errors** — Bump `channels.sesame.loopPrevention.maxConsecutive` (default is 3, try 50 for agent DMs)
+
+## Links
+
+- [Sesame docs](https://sesame.space/docs)
+- [Sesame SDK](https://www.npmjs.com/package/@sesamespace/sdk)
+- [OpenClaw docs](https://docs.openclaw.ai)

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Sesame Channel Plugin for OpenClaw
+ *
+ * Connects your OpenClaw agent to the Sesame messaging platform.
+ * Install: openclaw plugins install @sesamespace/openclaw
+ *
+ * Config (openclaw.json):
+ *   channels.sesame.enabled: true
+ *   channels.sesame.apiKey: "your-sesame-api-key"
+ *   channels.sesame.allowFrom: ["*"]  // Trust Sesame's permission model
+ *
+ * That's it. The plugin handles WebSocket connection, authentication,
+ * heartbeats, reconnection, and message routing automatically.
+ */
+type OpenClawPluginApi = any;
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        additionalProperties: false;
+        properties: {};
+    };
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,520 @@
+/**
+ * Sesame Channel Plugin for OpenClaw
+ *
+ * Connects your OpenClaw agent to the Sesame messaging platform.
+ * Install: openclaw plugins install @sesamespace/openclaw
+ *
+ * Config (openclaw.json):
+ *   channels.sesame.enabled: true
+ *   channels.sesame.apiKey: "your-sesame-api-key"
+ *   channels.sesame.allowFrom: ["*"]  // Trust Sesame's permission model
+ *
+ * That's it. The plugin handles WebSocket connection, authentication,
+ * heartbeats, reconnection, and message routing automatically.
+ */
+// Runtime state
+let pluginRuntime = null;
+// Connection state per account
+const connections = new Map();
+function getLogger() {
+    return (pluginRuntime?.logging?.getChildLogger?.({ plugin: "sesame" }) ?? console);
+}
+const sesameChannelPlugin = {
+    id: "sesame",
+    meta: {
+        id: "sesame",
+        label: "Sesame",
+        selectionLabel: "Sesame (Agent-Native)",
+        docsPath: "/channels/sesame",
+        blurb: "Agent-native communications platform for human-agent collaboration.",
+        aliases: ["ses"],
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: false,
+        reactions: true,
+        threads: true,
+        editing: true,
+        mentions: true,
+    },
+    reload: { configPrefixes: ["channels.sesame"] },
+    config: {
+        listAccountIds: (cfg) => {
+            const sesame = cfg.channels?.sesame;
+            if (sesame?.enabled && sesame?.apiKey)
+                return ["default"];
+            return [];
+        },
+        resolveAccount: (cfg, accountId) => {
+            const sesame = cfg.channels?.sesame;
+            if (!sesame?.enabled || !sesame?.apiKey)
+                return null;
+            return {
+                accountId: accountId ?? "default",
+                apiUrl: sesame.apiUrl ?? "https://api.sesame.space",
+                wsUrl: sesame.wsUrl ?? "wss://ws.sesame.space",
+                apiKey: sesame.apiKey ?? "",
+                agentId: sesame.agentId,
+                channels: sesame.channels ?? [],
+                allowFrom: sesame.allowFrom ?? [],
+            };
+        },
+        defaultAccountId: () => "default",
+    },
+    status: {
+        defaultRuntime: {
+            accountId: "default",
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+        }),
+        probeAccount: async ({ account, timeoutMs }) => {
+            try {
+                const response = await fetch(`${account.apiUrl}/api/v1/agents/me/manifest`, {
+                    headers: { Authorization: `Bearer ${account.apiKey}` },
+                    signal: AbortSignal.timeout(timeoutMs ?? 5000),
+                });
+                if (response.ok) {
+                    const data = (await response.json());
+                    return { ok: true, agent: data.data?.agent ?? data.agent };
+                }
+                return { ok: false, error: `API returned ${response.status}` };
+            }
+            catch (err) {
+                return { ok: false, error: String(err) };
+            }
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const log = ctx.log ?? getLogger();
+            if (!account?.apiKey) {
+                log.warn?.("[sesame] No API key configured");
+                return;
+            }
+            log.info?.(`[sesame] [${account.accountId}] starting provider`);
+            // Return a long-lived promise that resolves only when aborted
+            return new Promise((resolve) => {
+                ctx.abortSignal?.addEventListener("abort", () => {
+                    disconnect(account.accountId);
+                    resolve();
+                });
+                connect(account, ctx);
+            });
+        },
+        stopAccount: async (ctx) => {
+            const account = ctx.account;
+            const log = ctx.log ?? getLogger();
+            log.info?.(`[sesame] [${account.accountId}] stopping provider`);
+            disconnect(account.accountId);
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 4000,
+        resolveTarget: (params) => {
+            const raw = params.to;
+            if (!raw)
+                return { ok: false, error: new Error("No target specified") };
+            const normalized = raw.startsWith("sesame:") ? raw : `sesame:${raw}`;
+            return { ok: true, to: normalized };
+        },
+        sendText: async (ctx) => {
+            const { text, to, cfg, accountId } = ctx;
+            const account = sesameChannelPlugin.config.resolveAccount(cfg, accountId);
+            if (!account?.apiKey)
+                throw new Error("Sesame not configured");
+            const channelId = to?.startsWith("sesame:") ? to.slice(7) : to;
+            const response = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${account.apiKey}`,
+                },
+                body: JSON.stringify({ content: text, kind: "text", intent: "chat" }),
+            });
+            if (!response.ok) {
+                const error = (await response.json().catch(() => ({})));
+                throw new Error(error.error ?? response.statusText);
+            }
+            const result = (await response.json().catch(() => ({})));
+            return {
+                channel: "sesame",
+                messageId: result.data?.id ?? result.id ?? "unknown",
+                chatId: channelId,
+            };
+        },
+        sendMedia: async (ctx) => {
+            // Sesame doesn't support media attachments yet — fall back to text
+            const text = ctx.caption ?? ctx.text ?? "[media attachment]";
+            return sesameChannelPlugin.outbound.sendText({ ...ctx, text });
+        },
+    },
+    messaging: {
+        normalizeTarget: (raw) => {
+            if (raw.startsWith("sesame:"))
+                return raw;
+            return `sesame:${raw}`;
+        },
+    },
+    directory: {
+        listGroups: async (params) => {
+            const sesame = params.cfg?.channels?.sesame;
+            if (!sesame?.enabled)
+                return [];
+            return (sesame.channels ?? []).map((id) => ({
+                id: `sesame:${id}`,
+                kind: "group",
+                name: id,
+                handle: id,
+            }));
+        },
+        listPeers: async (params) => {
+            const sesame = params.cfg?.channels?.sesame;
+            if (!sesame?.enabled)
+                return [];
+            return (sesame.allowFrom ?? [])
+                .filter((id) => id !== "*")
+                .map((id) => ({
+                id: `sesame:${id}`,
+                kind: "user",
+                name: id,
+                handle: id,
+            }));
+        },
+    },
+};
+// ── WebSocket connection ──
+async function connect(account, ctx) {
+    const log = ctx.log ?? getLogger();
+    const WebSocket = (await import("ws")).default;
+    disconnect(account.accountId);
+    const state = {
+        ws: null,
+        heartbeatTimer: null,
+        reconnectTimer: null,
+        authenticated: false,
+        agentId: account.agentId ?? null,
+        stopping: false,
+        ctx,
+        channelMap: new Map(),
+    };
+    connections.set(account.accountId, state);
+    try {
+        // Fetch manifest: resolve agent ID + cache channel metadata
+        try {
+            const res = await fetch(`${account.apiUrl}/api/v1/agents/me/manifest`, { headers: { Authorization: `Bearer ${account.apiKey}` } });
+            if (res.ok) {
+                const manifest = (await res.json());
+                const mData = manifest.data ?? manifest;
+                if (!state.agentId) {
+                    state.agentId = mData.agent?.id;
+                    log.info?.(`[sesame] Agent ID resolved: ${state.agentId}`);
+                }
+                // Cache channel metadata for ChatType resolution
+                for (const ch of mData.channels ?? []) {
+                    state.channelMap.set(ch.id, { kind: ch.kind, name: ch.name });
+                }
+                log.info?.(`[sesame] Loaded ${state.channelMap.size} channels from manifest`);
+            }
+        }
+        catch (err) {
+            log.warn?.(`[sesame] Could not fetch manifest: ${err}`);
+        }
+        state.ws = new WebSocket(`${account.wsUrl}/v1/connect`);
+        state.ws.on("open", () => {
+            log.info?.("[sesame] WebSocket connected, authenticating...");
+            state.ws?.send(JSON.stringify({ type: "auth", apiKey: account.apiKey }));
+        });
+        state.ws.on("message", (data) => {
+            try {
+                const event = JSON.parse(data.toString());
+                if (event.type !== "pong" &&
+                    event.type !== "typing" &&
+                    event.type !== "delivery.ack" &&
+                    event.type !== "presence" &&
+                    event.type !== "read_receipt") {
+                    log.debug?.(`[sesame] Event: ${event.type}`);
+                }
+                handleEvent(event, account, state, ctx);
+            }
+            catch (e) {
+                log.error?.(`[sesame] WS parse error: ${e}`);
+            }
+        });
+        state.ws.on("close", (code) => {
+            state.authenticated = false;
+            clearInterval(state.heartbeatTimer);
+            if (state.stopping)
+                return;
+            log.info?.(`[sesame] WebSocket disconnected (code=${code}), reconnecting in 5s...`);
+            state.reconnectTimer = setTimeout(() => connect(account, ctx), 5000);
+        });
+        state.ws.on("error", (err) => {
+            log.error?.("[sesame] WebSocket error", err);
+        });
+    }
+    catch (err) {
+        log.error?.("[sesame] Connection failed", err);
+        state.reconnectTimer = setTimeout(() => connect(account, ctx), 5000);
+    }
+}
+function disconnect(accountId) {
+    const state = connections.get(accountId);
+    if (!state)
+        return;
+    state.stopping = true;
+    clearInterval(state.heartbeatTimer);
+    clearTimeout(state.reconnectTimer);
+    try {
+        state.ws?.close();
+    }
+    catch { }
+    connections.delete(accountId);
+}
+function handleEvent(event, account, state, ctx) {
+    const log = ctx.log ?? getLogger();
+    switch (event.type) {
+        case "authenticated":
+            state.authenticated = true;
+            state.heartbeatTimer = setInterval(() => {
+                if (state.ws?.readyState === 1) {
+                    state.ws.send(JSON.stringify({ type: "ping" }));
+                }
+            }, event.heartbeatIntervalMs ?? 30000);
+            log.info?.("[sesame] Authenticated successfully");
+            state.ws?.send(JSON.stringify({ type: "replay", cursors: {} }));
+            break;
+        case "message":
+            handleMessage(event.message ?? event.data, account, state, ctx);
+            break;
+        case "membership": {
+            // Track new channel joins so ChatType resolves correctly
+            const mData = event.data ?? event.membership ?? event;
+            const mChannelId = mData.channelId;
+            const mChannel = mData.channel;
+            if (mData.principalId === state.agentId &&
+                mData.action === "joined" &&
+                mChannelId) {
+                if (!state.channelMap.has(mChannelId)) {
+                    state.channelMap.set(mChannelId, {
+                        kind: mChannel?.kind ?? "group",
+                        name: mChannel?.name,
+                    });
+                    log.info?.(`[sesame] Joined channel ${mChannel?.name ?? mChannelId}`);
+                }
+            }
+            break;
+        }
+        case "pong":
+            break;
+        case "error":
+            log.error?.("[sesame] Server error:", event.message);
+            break;
+    }
+}
+async function handleMessage(message, account, state, ctx) {
+    const log = ctx.log ?? getLogger();
+    const core = pluginRuntime;
+    if (!core)
+        return;
+    const bodyText = message.content ?? message.plaintext ?? message.body ?? message.text ?? "";
+    const channelId = message.channelId;
+    const messageId = message.id;
+    log.info?.(`[sesame] Message from ${message.senderId} in ${channelId}: "${bodyText.slice(0, 100)}"`);
+    // Skip own messages
+    if (message.senderId === state.agentId)
+        return;
+    // Channel filter (empty = all channels)
+    if (account.channels.length > 0 && !account.channels.includes(channelId))
+        return;
+    // Sender allowlist — wildcard "*" means allow all (Sesame manages permissions)
+    const hasWildcard = account.allowFrom.includes("*");
+    if (account.allowFrom.length > 0 &&
+        !hasWildcard &&
+        !account.allowFrom.includes(message.senderId))
+        return;
+    // Resolve sender info from message metadata
+    const meta = message.metadata ?? {};
+    const senderName = meta.senderDisplayName ??
+        meta.senderHandle ??
+        message.senderDisplayName ??
+        message.sender?.displayName ??
+        message.sender?.handle ??
+        message.senderId;
+    const senderHandle = meta.senderHandle ?? message.sender?.handle ?? message.senderId;
+    // Resolve channel kind (dm vs group) from cached manifest data
+    let channelInfo = state.channelMap.get(channelId);
+    if (!channelInfo) {
+        // Channel not in cache — fetch from API
+        try {
+            const chRes = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}`, { headers: { Authorization: `Bearer ${account.apiKey}` } });
+            if (chRes.ok) {
+                const chData = (await chRes.json());
+                const ch = chData.data ?? chData;
+                channelInfo = { kind: ch.kind ?? "group", name: ch.name };
+                state.channelMap.set(channelId, channelInfo);
+                log.info?.(`[sesame] Fetched channel info: ${ch.name ?? channelId} (${ch.kind})`);
+            }
+        }
+        catch (err) {
+            log.warn?.(`[sesame] Could not fetch channel ${channelId}: ${err}`);
+        }
+    }
+    const channelKind = channelInfo?.kind ?? "group";
+    const channelName = channelInfo?.name;
+    const isGroup = channelKind !== "dm";
+    const chatType = isGroup ? "group" : "direct";
+    log.info?.(`[sesame] Dispatching to OpenClaw... (chatType=${chatType}, channel=${channelName ?? channelId})`);
+    // Typing indicator
+    const sendTyping = () => {
+        const conn = connections.get(account.accountId);
+        if (conn?.ws?.readyState === 1 && conn.authenticated) {
+            conn.ws.send(JSON.stringify({ type: "typing", channelId }));
+        }
+    };
+    let typingStopped = false;
+    sendTyping();
+    const typingInterval = setInterval(() => {
+        if (!typingStopped)
+            sendTyping();
+    }, 2500);
+    try {
+        const cfg = core.config.loadConfig();
+        // Resolve agent route
+        const route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "sesame",
+            accountId: account.accountId,
+            peer: {
+                kind: isGroup ? "group" : "direct",
+                id: isGroup ? channelId : message.senderId,
+            },
+        });
+        // Build Sesame-specific session key per channel
+        const channelIdShort = channelId.slice(0, 7);
+        const sesameSessionKey = `agent:main:sesame:${chatType}:${channelIdShort}`;
+        log.info?.(`[sesame] Route: sessionKey=${sesameSessionKey} matchedBy=${route.matchedBy}`);
+        // Build conversation label
+        const conversationLabel = isGroup
+            ? channelName
+                ? `#${channelName}`
+                : `sesame-group:${channelIdShort}`
+            : senderName;
+        const inboundCtx = core.channel.reply.finalizeInboundContext({
+            Body: bodyText,
+            BodyForAgent: bodyText,
+            RawBody: bodyText,
+            CommandBody: bodyText,
+            From: `sesame:${channelId}`,
+            To: `sesame:${channelId}`,
+            SessionKey: sesameSessionKey,
+            AccountId: account.accountId,
+            ChatType: chatType,
+            IsGroup: isGroup,
+            ConversationLabel: conversationLabel,
+            SenderName: senderName,
+            SenderId: message.senderId,
+            SenderUsername: senderHandle,
+            Provider: "sesame",
+            Surface: "sesame",
+            MessageSid: messageId,
+            Timestamp: message.createdAt
+                ? new Date(message.createdAt).getTime()
+                : Date.now(),
+            OriginatingChannel: "sesame",
+            CommandAuthorized: true,
+            CommandSource: "text",
+        });
+        // Record session
+        const storePath = core.channel.session.resolveStorePath(cfg.session?.store, { channel: "sesame", accountId: account.accountId });
+        await core.channel.session.recordInboundSession({
+            storePath,
+            sessionKey: inboundCtx.SessionKey ?? sesameSessionKey,
+            ctx: inboundCtx,
+        });
+        // Buffer reply chunks and send as a single message
+        const replyBuffer = [];
+        const flushBuffer = async () => {
+            const fullReply = replyBuffer.join("\n\n").trim();
+            if (!fullReply)
+                return;
+            log.info?.(`[sesame] Flushing buffered reply (${fullReply.length} chars): "${fullReply.slice(0, 100)}"`);
+            const res = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${account.apiKey}`,
+                },
+                body: JSON.stringify({
+                    content: fullReply,
+                    kind: "text",
+                    intent: "chat",
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.text().catch(() => "");
+                log.error?.(`[sesame] Send failed (${res.status}): ${err.slice(0, 200)}`);
+            }
+            else {
+                log.info?.(`[sesame] Sent buffered reply to ${channelId} (${res.status})`);
+            }
+        };
+        const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+            humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
+            onReplyStart: () => sendTyping(),
+            onIdle: () => clearInterval(typingInterval),
+            deliver: async (payload) => {
+                const replyText = payload.text ?? payload.body ?? payload.content ?? "";
+                if (replyText)
+                    replyBuffer.push(replyText);
+            },
+            onError: (err) => {
+                log.error?.(`[sesame] Reply failed: ${String(err)}`);
+            },
+        });
+        await core.channel.reply.dispatchReplyFromConfig({
+            ctx: inboundCtx,
+            cfg,
+            dispatcher,
+            replyOptions,
+        });
+        typingStopped = true;
+        clearInterval(typingInterval);
+        markDispatchIdle();
+        await flushBuffer();
+        log.info?.("[sesame] Dispatch complete");
+    }
+    catch (err) {
+        log.error?.(`[sesame] Dispatch error: ${String(err)}`);
+    }
+    finally {
+        typingStopped = true;
+        clearInterval(typingInterval);
+    }
+}
+// ── Plugin export ──
+const plugin = {
+    id: "sesame",
+    name: "Sesame",
+    description: "Connect your OpenClaw agent to Sesame — the agent-native messaging platform",
+    configSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+    },
+    register(api) {
+        pluginRuntime = api.runtime;
+        api.registerChannel({ plugin: sesameChannelPlugin });
+    },
+};
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,36 @@
+{
+  "id": "sesame",
+  "name": "Sesame",
+  "version": "0.2.1",
+  "description": "Connect your OpenClaw agent to Sesame — the agent-native messaging platform",
+  "channels": ["sesame"],
+  "channel": {
+    "id": "sesame",
+    "label": "Sesame",
+    "selectionLabel": "Sesame (Agent-Native)",
+    "docsPath": "/channels/sesame",
+    "blurb": "Agent-native communications platform for human-agent collaboration.",
+    "order": 80,
+    "aliases": ["ses"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean" },
+      "apiKey": { "type": "string" },
+      "apiUrl": { "type": "string" },
+      "wsUrl": { "type": "string" },
+      "agentId": { "type": "string" },
+      "channels": { "type": "array", "items": { "type": "string" } },
+      "allowFrom": { "type": "array", "items": { "type": "string" } }
+    }
+  },
+  "uiHints": {
+    "apiKey": { "label": "API Key", "sensitive": true, "placeholder": "sk_..." },
+    "apiUrl": { "label": "API URL", "placeholder": "https://api.sesame.space" },
+    "wsUrl": { "label": "WebSocket URL", "placeholder": "wss://ws.sesame.space" },
+    "channels": { "label": "Channel IDs to listen on (empty = all)" },
+    "allowFrom": { "label": "Allowed sender IDs (empty = all)" }
+  }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@sesamespace/sesame",
+  "version": "0.2.1",
+  "description": "Sesame channel plugin for OpenClaw — connect your AI agent to the Sesame messaging platform",
+  "type": "module",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baileydavis2026/sesame.git",
+    "directory": "packages/openclaw-plugin"
+  },
+  "homepage": "https://sesame.space/docs",
+  "keywords": [
+    "sesame",
+    "openclaw",
+    "agent",
+    "messaging",
+    "channel",
+    "plugin",
+    "ai-agent",
+    "multi-agent"
+  ],
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "channel": {
+      "id": "sesame",
+      "label": "Sesame",
+      "selectionLabel": "Sesame (Agent-Native)",
+      "docsPath": "/channels/sesame",
+      "docsLabel": "sesame",
+      "blurb": "Agent-native communications platform for human-agent collaboration.",
+      "order": 80,
+      "aliases": [
+        "ses"
+      ]
+    },
+    "install": {
+      "npmSpec": "@sesamespace/sesame",
+      "defaultChoice": "npm"
+    }
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}