@sesamespace/sesame 0.2.2 → 0.2.4

package/dist/index.js

@@ -16,9 +16,24 @@
 let pluginRuntime = null;
 // Connection state per account
 const connections = new Map();
+// Streaming state: tracks channels where streaming already delivered the message
+// Key: channelId, Value: { messageId, text } — outbound.sendText should edit instead of send
+const streamDelivered = new Map();
 function getLogger() {
     return (pluginRuntime?.logging?.getChildLogger?.({ plugin: "sesame" }) ?? console);
 }
+function guessContentType(fileName) {
+    const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+    const map = {
+        jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif",
+        webp: "image/webp", svg: "image/svg+xml", pdf: "application/pdf",
+        mp3: "audio/mpeg", mp4: "video/mp4", webm: "video/webm",
+        json: "application/json", txt: "text/plain", md: "text/markdown",
+        csv: "text/csv", html: "text/html", xml: "application/xml",
+        zip: "application/zip", tar: "application/x-tar", gz: "application/gzip",
+    };
+    return map[ext] ?? "application/octet-stream";
+}
 const sesameChannelPlugin = {
     id: "sesame",
     meta: {
@@ -31,7 +46,7 @@ const sesameChannelPlugin = {
     },
     capabilities: {
         chatTypes: ["direct", "group"],
-        media: false,
+        media: true,
         reactions: true,
         threads: true,
         editing: true,
@@ -134,6 +149,30 @@ const sesameChannelPlugin = {
             if (!account?.apiKey)
                 throw new Error("Sesame not configured");
             const channelId = to?.startsWith("sesame:") ? to.slice(7) : to;
+            const log = getLogger();
+            // Check if streaming already delivered this message
+            const delivered = streamDelivered.get(channelId);
+            if (delivered) {
+                streamDelivered.delete(channelId);
+                // Do a final edit to ensure the complete text is correct, then return
+                log.info?.(`[sesame] outbound.sendText: streaming already sent to ${channelId}, doing final edit`);
+                const editRes = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages/${delivered.messageId}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({ content: text }),
+                });
+                if (!editRes.ok) {
+                    log.warn?.(`[sesame] Final stream edit in sendText failed (${editRes.status})`);
+                }
+                return {
+                    channel: "sesame",
+                    messageId: delivered.messageId,
+                    chatId: channelId,
+                };
+            }
             const response = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
                 method: "POST",
                 headers: {
@@ -154,9 +193,108 @@ const sesameChannelPlugin = {
             };
         },
         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 });
+            const { text, mediaUrl, cfg, accountId } = ctx;
+            const account = sesameChannelPlugin.config.resolveAccount(cfg, accountId);
+            if (!account?.apiKey)
+                throw new Error("Sesame not configured");
+            const channelId = ctx.to?.startsWith("sesame:") ? ctx.to.slice(7) : ctx.to;
+            const caption = ctx.caption ?? text ?? "";
+            const log = getLogger();
+            try {
+                // Resolve media source: local file path or URL
+                const fs = await import("fs");
+                const path = await import("path");
+                let fileBuffer;
+                let fileName;
+                let contentType;
+                if (mediaUrl && (mediaUrl.startsWith("/") || mediaUrl.startsWith("~"))) {
+                    // Local file path
+                    const resolvedPath = mediaUrl.startsWith("~")
+                        ? mediaUrl.replace("~", process.env.HOME ?? "")
+                        : mediaUrl;
+                    fileBuffer = fs.readFileSync(resolvedPath);
+                    fileName = path.basename(resolvedPath);
+                    contentType = guessContentType(fileName);
+                }
+                else if (mediaUrl) {
+                    // Remote URL — download it
+                    const response = await fetch(mediaUrl);
+                    if (!response.ok)
+                        throw new Error(`Failed to download media: ${response.status}`);
+                    fileBuffer = Buffer.from(await response.arrayBuffer());
+                    // Extract filename from URL or Content-Disposition
+                    const urlPath = new URL(mediaUrl).pathname;
+                    fileName = path.basename(urlPath) || "attachment";
+                    contentType = response.headers.get("content-type") ?? guessContentType(fileName);
+                }
+                else {
+                    // No media URL — fall back to text
+                    return sesameChannelPlugin.outbound.sendText({ ...ctx, text: caption || "[media attachment]" });
+                }
+                // 1. Get presigned upload URL from Sesame Drive
+                const uploadRes = await fetch(`${account.apiUrl}/api/v1/drive/files/upload-url`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({ fileName, contentType, size: fileBuffer.length }),
+                });
+                if (!uploadRes.ok)
+                    throw new Error(`Drive upload-url failed: ${uploadRes.status}`);
+                const uploadData = (await uploadRes.json());
+                const { uploadUrl, fileId, s3Key } = uploadData.data;
+                // 2. Upload to S3
+                const s3Res = await fetch(uploadUrl, {
+                    method: "PUT",
+                    headers: { "Content-Type": contentType },
+                    body: new Uint8Array(fileBuffer),
+                });
+                if (!s3Res.ok)
+                    throw new Error(`S3 upload failed: ${s3Res.status}`);
+                // 3. Register file in Drive
+                const regRes = await fetch(`${account.apiUrl}/api/v1/drive/files`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({ fileId, s3Key, fileName, contentType, size: fileBuffer.length }),
+                });
+                if (!regRes.ok)
+                    throw new Error(`Drive register failed: ${regRes.status}`);
+                // 4. Send message with attachment
+                const msgRes = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        content: caption || fileName,
+                        kind: "text",
+                        intent: "chat",
+                        attachmentIds: [fileId],
+                    }),
+                });
+                if (!msgRes.ok)
+                    throw new Error(`Send message failed: ${msgRes.status}`);
+                const msgData = (await msgRes.json());
+                log.info?.(`[sesame] Sent file "${fileName}" (${fileBuffer.length} bytes) to ${channelId}`);
+                return {
+                    channel: "sesame",
+                    messageId: msgData.data?.id ?? msgData.id ?? "unknown",
+                    chatId: channelId,
+                };
+            }
+            catch (err) {
+                log.error?.(`[sesame] sendMedia failed: ${err}`);
+                // Fall back to text with caption
+                return sesameChannelPlugin.outbound.sendText({
+                    ...ctx,
+                    text: caption || "[media attachment — upload failed]",
+                });
+            }
         },
     },
     messaging: {
@@ -193,6 +331,90 @@ const sesameChannelPlugin = {
         },
     },
 };
+// ── Wake Context (cold start optimization) ──
+async function fetchWakeContext(account, agentId, ctx) {
+    const log = getLogger();
+    try {
+        const response = await fetch(`${account.apiUrl}/api/v1/agents/${agentId}/wake`, { headers: { Authorization: `Bearer ${account.apiKey}` } });
+        if (!response.ok) {
+            log.warn?.(`[sesame] Wake endpoint returned ${response.status}`);
+            return;
+        }
+        const result = await response.json();
+        if (!result.ok)
+            return;
+        const data = result.data;
+        const lines = ["[Sesame Platform Context]"];
+        // Focused task
+        if (data.focusedTask) {
+            const t = data.focusedTask;
+            lines.push(`\nFocused Task: T-${t.taskNumber} — ${t.title} (${t.status})`);
+            if (t.context?.notes)
+                lines.push(`Notes: ${t.context.notes}`);
+            if (t.context?.background)
+                lines.push(`Background: ${t.context.background}`);
+        }
+        // Active tasks summary
+        const active = data.tasks?.active ?? [];
+        const blocked = data.tasks?.blocked ?? [];
+        const todo = data.tasks?.todo ?? [];
+        if (active.length + blocked.length + todo.length > 0) {
+            lines.push(`\nTasks: ${active.length} active, ${blocked.length} blocked, ${todo.length} todo`);
+            for (const t of active.slice(0, 5)) {
+                lines.push(`  [active] T-${t.taskNumber}: ${t.title}`);
+            }
+            for (const t of blocked.slice(0, 3)) {
+                lines.push(`  [blocked] T-${t.taskNumber}: ${t.title}`);
+            }
+        }
+        // Unread channels
+        const unread = data.channels?.unread ?? [];
+        if (unread.length > 0) {
+            lines.push(`\nUnread: ${unread.length} channel${unread.length > 1 ? "s" : ""} with unread messages`);
+        }
+        // Upcoming schedule
+        const upcoming = data.schedule?.upcoming ?? [];
+        if (upcoming.length > 0) {
+            lines.push(`\nSchedule: ${upcoming.length} upcoming event${upcoming.length > 1 ? "s" : ""}`);
+            for (const e of upcoming.slice(0, 3)) {
+                lines.push(`  ${e.title} — ${e.nextOccurrenceAt ?? "soon"}`);
+            }
+        }
+        // Pinned memories
+        const pinned = data.memory?.pinned ?? [];
+        if (pinned.length > 0) {
+            lines.push(`\nPinned Memories:`);
+            for (const m of pinned.slice(0, 10)) {
+                lines.push(`  [${m.category}/${m.key}] ${m.content.slice(0, 200)}`);
+            }
+        }
+        // Session state
+        if (data.state?.state) {
+            lines.push(`\nSession State: ${JSON.stringify(data.state.state).slice(0, 500)}`);
+        }
+        // Inject as system context via wake event
+        if (lines.length > 1) {
+            const contextText = lines.join("\n");
+            log.info?.(`[sesame] Injecting wake context (${contextText.length} chars)`);
+            // Use the OpenClaw plugin API to inject a wake event
+            try {
+                const runtime = pluginRuntime;
+                if (runtime?.events?.emit) {
+                    runtime.events.emit("wake", {
+                        text: contextText,
+                        source: "sesame-wake",
+                    });
+                }
+            }
+            catch (e) {
+                log.warn?.(`[sesame] Could not inject wake event: ${e}`);
+            }
+        }
+    }
+    catch (err) {
+        log.warn?.(`[sesame] Wake context error: ${err}`);
+    }
+}
 // ── WebSocket connection ──
 async function connect(account, ctx) {
     const log = ctx.log ?? getLogger();
@@ -207,6 +429,9 @@ async function connect(account, ctx) {
         stopping: false,
         ctx,
         channelMap: new Map(),
+        sentMessageIds: new Set(),
+        recentOutboundCount: 0,
+        outboundWindowStart: Date.now(),
     };
     connections.set(account.accountId, state);
     try {
@@ -286,6 +511,10 @@ function handleEvent(event, account, state, ctx) {
     switch (event.type) {
         case "authenticated":
             state.authenticated = true;
+            if (event.principalId && !state.agentId) {
+                state.agentId = event.principalId;
+                log.info?.(`[sesame] Agent ID from auth: ${state.agentId}`);
+            }
             state.heartbeatTimer = setInterval(() => {
                 if (state.ws?.readyState === 1) {
                     state.ws.send(JSON.stringify({ type: "ping" }));
@@ -293,10 +522,67 @@ function handleEvent(event, account, state, ctx) {
             }, event.heartbeatIntervalMs ?? 30000);
             log.info?.("[sesame] Authenticated successfully");
             state.ws?.send(JSON.stringify({ type: "replay", cursors: {} }));
+            // Call wake endpoint for cold start context (fire and forget)
+            if (state.agentId) {
+                fetchWakeContext(account, state.agentId, ctx).catch((err) => log.warn?.(`[sesame] Wake context fetch failed: ${err}`));
+            }
             break;
-        case "message":
-            handleMessage(event.message ?? event.data, account, state, ctx);
+        case "message": {
+            const msg = event.message ?? event.data;
+            // For voice messages: check if transcript is available.
+            // If not, check plaintext (API may have set it during sync transcription).
+            // Only skip if neither is available — wait for voice.transcribed event.
+            if (msg?.kind === "voice") {
+                const meta = msg.metadata ?? {};
+                const transcript = meta.transcript;
+                const plaintext = msg.plaintext;
+                const hasTranscript = transcript || (plaintext && plaintext !== "(voice note)");
+                if (!hasTranscript) {
+                    log.info?.(`[sesame] Voice message ${msg.id} — no transcript yet, waiting for voice.transcribed (30s fallback)`);
+                    // Track pending voice messages for fallback delivery
+                    const pendingKey = `voice:${msg.id}`;
+                    state.sentMessageIds.add(pendingKey); // reuse set to track pending
+                    setTimeout(() => {
+                        if (state.sentMessageIds.has(pendingKey)) {
+                            state.sentMessageIds.delete(pendingKey);
+                            log.warn?.(`[sesame] Voice message ${msg.id} — transcription timeout, delivering without transcript`);
+                            handleMessage(msg, account, state, ctx);
+                        }
+                    }, 30000);
+                    break;
+                }
+            }
+            handleMessage(msg, account, state, ctx);
+            break;
+        }
+        case "voice.transcribed": {
+            // Transcription completed — dispatch as a regular message with transcript text
+            const vtData = event;
+            const transcript = vtData.transcript;
+            const messageId = vtData.messageId;
+            const channelId = vtData.channelId;
+            const senderId = vtData.senderId;
+            if (!transcript || !messageId || !channelId) {
+                log.warn?.("[sesame] voice.transcribed event missing fields");
+                break;
+            }
+            // Clear pending fallback so we don't double-deliver
+            const pendingKey = `voice:${messageId}`;
+            state.sentMessageIds.delete(pendingKey);
+            log.info?.(`[sesame] Voice transcribed for ${messageId}: "${transcript.slice(0, 80)}"`);
+            // Build a synthetic message object so handleMessage can process it
+            handleMessage({
+                id: messageId,
+                channelId,
+                senderId,
+                kind: "voice",
+                content: transcript,
+                plaintext: transcript,
+                metadata: { transcript },
+                createdAt: new Date().toISOString(),
+            }, account, state, ctx);
             break;
+        }
         case "membership": {
             // Track new channel joins so ChatType resolves correctly
             const mData = event.data ?? event.membership ?? event;
@@ -327,13 +613,40 @@ async function handleMessage(message, account, state, ctx) {
     const core = pluginRuntime;
     if (!core)
         return;
-    const bodyText = message.content ?? message.plaintext ?? message.body ?? message.text ?? "";
+    // For voice messages, prefer transcript from metadata over content
+    const msgMeta = message.metadata ?? {};
+    const voiceTranscript = message.kind === "voice" ? msgMeta.transcript : undefined;
+    // Prefer plaintext over content — plaintext includes attachment info block
+    // appended by the API (download URLs, file names, sizes)
+    const rawText = voiceTranscript ?? message.plaintext ?? message.content ?? message.body ?? message.text ?? "";
+    // If plaintext didn't include attachments but metadata does, build the block ourselves
+    let bodyText = message.kind === "voice" && rawText ? `(voice note)\n${rawText}` : rawText;
+    const attachments = msgMeta.attachments;
+    if (attachments?.length && !bodyText.includes("[Attachments]")) {
+        const lines = attachments.map((a) => {
+            const sizeKB = Math.round((a.size ?? 0) / 1024);
+            const sizeStr = sizeKB >= 1024 ? `${(sizeKB / 1024).toFixed(1)} MB` : `${sizeKB} KB`;
+            const dl = a.downloadUrl ? `\n  Download: ${a.downloadUrl}` : "";
+            return `- ${a.fileName ?? "file"} (${a.contentType ?? "unknown"}, ${sizeStr})${dl}`;
+        });
+        bodyText = bodyText + `\n\n[Attachments]\n${lines.join("\n")}`;
+    }
     const channelId = message.channelId;
     const messageId = message.id;
     log.info?.(`[sesame] Message from ${message.senderId} in ${channelId}: "${bodyText.slice(0, 100)}"`);
-    // Skip own messages
+    // Skip own messages (by sender ID)
     if (message.senderId === state.agentId)
         return;
+    // Skip messages we sent (by message ID tracking)
+    if (state.sentMessageIds.has(messageId)) {
+        state.sentMessageIds.delete(messageId);
+        return;
+    }
+    // Don't process messages until we know our own agent ID
+    if (!state.agentId) {
+        log.warn?.(`[sesame] Skipping message — agentId not resolved yet`);
+        return;
+    }
     // Channel filter (empty = all channels)
     if (account.channels.length > 0 && !account.channels.includes(channelId))
         return;
@@ -442,31 +755,102 @@ async function handleMessage(message, account, state, ctx) {
             sessionKey: inboundCtx.SessionKey ?? sesameSessionKey,
             ctx: inboundCtx,
         });
-        // Buffer reply chunks and send as a single message
+        // ── Streaming reply: send initial message, then edit in place ──
+        const sesameStreamMode = cfg.channels?.sesame?.streamMode ?? "buffer";
         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)}"`);
+        let streamMessageId = null;
+        let streamSending = false; // lock to prevent concurrent first-message sends
+        let streamEditTimer = null;
+        let streamPendingText = "";
+        const STREAM_EDIT_DEBOUNCE_MS = 300; // don't edit more than ~3x/sec
+        const trackSentMessage = (sentId) => {
+            state.sentMessageIds.add(sentId);
+            if (state.sentMessageIds.size > 1000) {
+                const first = state.sentMessageIds.values().next().value;
+                if (first)
+                    state.sentMessageIds.delete(first);
+            }
+        };
+        const sendNewMessage = async (text) => {
+            // Outbound circuit breaker: max 5 messages per 10s window
+            const cbNow = Date.now();
+            if (cbNow - state.outboundWindowStart > 10000) {
+                state.recentOutboundCount = 0;
+                state.outboundWindowStart = cbNow;
+            }
+            if (state.recentOutboundCount >= 5) {
+                log.error?.(`[sesame] Circuit breaker: suppressing outbound message`);
+                return null;
+            }
             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",
-                }),
+                body: JSON.stringify({ content: text, kind: "text", intent: "chat" }),
             });
             if (!res.ok) {
                 const err = await res.text().catch(() => "");
                 log.error?.(`[sesame] Send failed (${res.status}): ${err.slice(0, 200)}`);
+                return null;
+            }
+            state.recentOutboundCount++;
+            const resData = (await res.json().catch(() => ({})));
+            const sentId = resData.data?.id ?? resData.id ?? null;
+            if (sentId)
+                trackSentMessage(sentId);
+            return sentId;
+        };
+        const editMessage = async (msgId, text) => {
+            const res = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages/${msgId}`, {
+                method: "PATCH",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${account.apiKey}`,
+                },
+                body: JSON.stringify({ content: text }),
+            });
+            if (!res.ok) {
+                log.warn?.(`[sesame] Edit failed (${res.status})`);
+            }
+        };
+        const scheduleStreamEdit = () => {
+            if (streamEditTimer)
+                return; // already scheduled
+            streamEditTimer = setTimeout(async () => {
+                streamEditTimer = null;
+                if (streamMessageId && streamPendingText) {
+                    await editMessage(streamMessageId, streamPendingText);
+                }
+            }, STREAM_EDIT_DEBOUNCE_MS);
+        };
+        const flushBuffer = async () => {
+            const fullReply = replyBuffer.join("\n\n").trim();
+            // If nothing in buffer but we streamed via onPartialReply, do final edit with last known text
+            if (!fullReply && streamMessageId && streamPendingText) {
+                clearTimeout(streamEditTimer);
+                streamEditTimer = null;
+                await editMessage(streamMessageId, streamPendingText);
+                streamDelivered.set(channelId, { messageId: streamMessageId, text: streamPendingText });
+                log.info?.(`[sesame] Final stream edit from partial (${streamPendingText.length} chars), marked as delivered`);
+                return;
+            }
+            if (!fullReply)
+                return;
+            if (streamMessageId) {
+                // Final edit with complete text
+                clearTimeout(streamEditTimer);
+                streamEditTimer = null;
+                await editMessage(streamMessageId, fullReply);
+                // Signal to outbound.sendText that this channel was already handled
+                streamDelivered.set(channelId, { messageId: streamMessageId, text: fullReply });
+                log.info?.(`[sesame] Final stream edit (${fullReply.length} chars), marked as delivered`);
             }
             else {
-                log.info?.(`[sesame] Sent buffered reply to ${channelId} (${res.status})`);
+                // No streaming happened — don't send here, let outbound.sendText handle it
+                // (avoids double-send when OpenClaw calls both deliver + outbound.sendText)
+                log.info?.(`[sesame] Buffer mode: deferring to outbound.sendText (${fullReply.length} chars)`);
             }
         };
         const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
@@ -475,18 +859,56 @@ async function handleMessage(message, account, state, ctx) {
             onIdle: () => clearInterval(typingInterval),
             deliver: async (payload) => {
                 const replyText = payload.text ?? payload.body ?? payload.content ?? "";
-                if (replyText)
-                    replyBuffer.push(replyText);
+                if (!replyText)
+                    return;
+                replyBuffer.push(replyText);
+                const fullSoFar = replyBuffer.join("\n\n").trim();
+                if (sesameStreamMode === "partial" && fullSoFar.length > 0) {
+                    streamPendingText = fullSoFar;
+                    if (!streamMessageId && !streamSending) {
+                        // First chunk — send initial message (with lock to prevent race)
+                        streamSending = true;
+                        streamMessageId = await sendNewMessage(fullSoFar);
+                        streamSending = false;
+                        log.info?.(`[sesame] Stream started, msgId=${streamMessageId}`);
+                    }
+                    else if (streamMessageId) {
+                        // Subsequent chunks — debounced edit
+                        scheduleStreamEdit();
+                    }
+                    // If streamSending is true, another deliver call is already creating the message — skip
+                }
             },
             onError: (err) => {
                 log.error?.(`[sesame] Reply failed: ${String(err)}`);
             },
         });
+        // Add onPartialReply for real-time streaming (token-by-token updates)
+        const streamingReplyOptions = { ...replyOptions };
+        if (sesameStreamMode === "partial") {
+            streamingReplyOptions.onPartialReply = async (payload) => {
+                const text = payload.text;
+                if (!text)
+                    return;
+                streamPendingText = text;
+                if (!streamMessageId && !streamSending) {
+                    streamSending = true;
+                    streamMessageId = await sendNewMessage(text);
+                    streamSending = false;
+                    if (streamMessageId) {
+                        log.info?.(`[sesame] Stream started, msgId=${streamMessageId}`);
+                    }
+                }
+                else if (streamMessageId) {
+                    scheduleStreamEdit();
+                }
+            };
+        }
         await core.channel.reply.dispatchReplyFromConfig({
             ctx: inboundCtx,
             cfg,
             dispatcher,
-            replyOptions,
+            replyOptions: streamingReplyOptions,
         });
         typingStopped = true;
         clearInterval(typingInterval);

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "sesame",
   "name": "Sesame",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Connect your OpenClaw agent to Sesame — the agent-native messaging platform",
   "channels": ["sesame"],
   "channel": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sesamespace/sesame",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Sesame channel plugin for OpenClaw — connect your AI agent to the Sesame messaging platform",
   "type": "module",
   "main": "dist/index.js",
@@ -56,6 +56,7 @@
     "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@types/node": "^25.5.0",
     "typescript": "^5.9.3"
   }
 }