@sesamespace/sesame 0.2.3 → 0.2.5

package/dist/index.js

@@ -12,10 +12,25 @@
  * That's it. The plugin handles WebSocket connection, authentication,
  * heartbeats, reconnection, and message routing automatically.
  */
+// Plugin version (injected from package.json at build time, fallback to static)
+const PLUGIN_VERSION = "0.2.5";
+/** Standard headers for Sesame API calls */
+function sesameHeaders(apiKey, json = true) {
+    const h = {
+        Authorization: `Bearer ${apiKey}`,
+        "X-Sesame-Plugin-Version": PLUGIN_VERSION,
+    };
+    if (json)
+        h["Content-Type"] = "application/json";
+    return h;
+}
 // Runtime state
 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);
 }
@@ -91,7 +106,7 @@ const sesameChannelPlugin = {
         probeAccount: async ({ account, timeoutMs }) => {
             try {
                 const response = await fetch(`${account.apiUrl}/api/v1/agents/me/manifest`, {
-                    headers: { Authorization: `Bearer ${account.apiKey}` },
+                    headers: sesameHeaders(account.apiKey, false),
                     signal: AbortSignal.timeout(timeoutMs ?? 5000),
                 });
                 if (response.ok) {
@@ -146,12 +161,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: sesameHeaders(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: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${account.apiKey}`,
-                },
+                headers: sesameHeaders(account.apiKey),
                 body: JSON.stringify({ content: text, kind: "text", intent: "chat" }),
             });
             if (!response.ok) {
@@ -207,10 +240,7 @@ const sesameChannelPlugin = {
                 // 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}`,
-                    },
+                    headers: sesameHeaders(account.apiKey),
                     body: JSON.stringify({ fileName, contentType, size: fileBuffer.length }),
                 });
                 if (!uploadRes.ok)
@@ -228,10 +258,7 @@ const sesameChannelPlugin = {
                 // 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}`,
-                    },
+                    headers: sesameHeaders(account.apiKey),
                     body: JSON.stringify({ fileId, s3Key, fileName, contentType, size: fileBuffer.length }),
                 });
                 if (!regRes.ok)
@@ -239,10 +266,7 @@ const sesameChannelPlugin = {
                 // 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}`,
-                    },
+                    headers: sesameHeaders(account.apiKey),
                     body: JSON.stringify({
                         content: caption || fileName,
                         kind: "text",
@@ -304,6 +328,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: sesameHeaders(account.apiKey, false) });
+        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();
@@ -326,7 +434,7 @@ async function connect(account, ctx) {
     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}` } });
+            const res = await fetch(`${account.apiUrl}/api/v1/agents/me/manifest`, { headers: sesameHeaders(account.apiKey, false) });
             if (res.ok) {
                 const manifest = (await res.json());
                 const mData = manifest.data ?? manifest;
@@ -411,15 +519,33 @@ 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": {
             const msg = event.message ?? event.data;
-            // Skip voice messages without transcription — wait for voice.transcribed event
+            // 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;
-                if (!transcript) {
-                    log.info?.(`[sesame] Voice message ${msg.id} — waiting for transcription`);
+                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;
                 }
             }
@@ -437,6 +563,9 @@ function handleEvent(event, account, state, ctx) {
                 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({
@@ -484,8 +613,21 @@ async function handleMessage(message, account, state, ctx) {
     // For voice messages, prefer transcript from metadata over content
     const msgMeta = message.metadata ?? {};
     const voiceTranscript = message.kind === "voice" ? msgMeta.transcript : undefined;
-    const rawText = voiceTranscript ?? message.content ?? message.plaintext ?? message.body ?? message.text ?? "";
-    const bodyText = message.kind === "voice" && rawText ? `(voice note)\n${rawText}` : rawText;
+    // 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)}"`);
@@ -525,7 +667,7 @@ async function handleMessage(message, account, state, ctx) {
     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}` } });
+            const chRes = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}`, { headers: sesameHeaders(account.apiKey, false) });
             if (chRes.ok) {
                 const chData = (await chRes.json());
                 const ch = chData.data ?? chData;
@@ -610,12 +752,23 @@ 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;
+        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) {
@@ -623,45 +776,72 @@ async function handleMessage(message, account, state, ctx) {
                 state.outboundWindowStart = cbNow;
             }
             if (state.recentOutboundCount >= 5) {
-                log.error?.(`[sesame] Circuit breaker: suppressing outbound message (${state.recentOutboundCount} msgs in ${Math.round((cbNow - state.outboundWindowStart) / 1000)}s)`);
-                return;
+                log.error?.(`[sesame] Circuit breaker: suppressing outbound message`);
+                return null;
             }
-            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",
-                }),
+                headers: sesameHeaders(account.apiKey),
+                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;
             }
-            else {
-                log.info?.(`[sesame] Sent buffered reply to ${channelId} (${res.status})`);
-                // Track sent message ID to detect self-echoes
-                try {
-                    const resData = (await res.clone().json().catch(() => ({})));
-                    const sentId = resData.data?.id ?? resData.id;
-                    if (sentId) {
-                        state.sentMessageIds.add(sentId);
-                        // Cap set size at 1000
-                        if (state.sentMessageIds.size > 1000) {
-                            const first = state.sentMessageIds.values().next().value;
-                            if (first)
-                                state.sentMessageIds.delete(first);
-                        }
-                    }
+            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: sesameHeaders(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);
                 }
-                catch { }
-                // Track outbound count for circuit breaker
-                state.recentOutboundCount++;
+            }, 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 {
+                // 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({
@@ -670,18 +850,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/package.json

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