@stagewhisper/stagewhisper 0.57.0 → 0.60.0

package/dist/index.js

@@ -98,6 +98,75 @@ var init_client = __esm({
           throw new Error(`Reply failed (${res.status}): ${text}`);
         }
       }
+      async postChatReply(userMessageId, content, options) {
+        const body = {
+          content,
+          status: options?.status ?? "completed"
+        };
+        if (options?.errorCode) body.error_code = options.errorCode;
+        if (options?.errorMessage) body.error_message = options.errorMessage;
+        if (options?.metadata) body.metadata_ = options.metadata;
+        const res = await fetch(
+          `${this.baseUrl}/api/v1/openclaw/chat/messages/${userMessageId}/reply`,
+          {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(body)
+          }
+        );
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(`Chat reply failed (${res.status}): ${text}`);
+        }
+      }
+      async startChatReply(userMessageId) {
+        const res = await fetch(
+          `${this.baseUrl}/api/v1/openclaw/chat/messages/${userMessageId}/reply/start`,
+          {
+            method: "POST",
+            headers: this.headers()
+          }
+        );
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(`Chat reply start failed (${res.status}): ${text}`);
+        }
+        return await res.json();
+      }
+      async postChatReplyDelta(assistantMessageId, delta) {
+        const res = await fetch(
+          `${this.baseUrl}/api/v1/openclaw/chat/messages/${assistantMessageId}/reply/delta`,
+          {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify({ delta })
+          }
+        );
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(`Chat reply delta failed (${res.status}): ${text}`);
+        }
+      }
+      async completeChatReply(assistantMessageId, options) {
+        const body = {
+          status: options?.status ?? "completed"
+        };
+        if (options?.content !== void 0) body.content = options.content;
+        if (options?.errorCode) body.error_code = options.errorCode;
+        if (options?.errorMessage) body.error_message = options.errorMessage;
+        const res = await fetch(
+          `${this.baseUrl}/api/v1/openclaw/chat/messages/${assistantMessageId}/reply/complete`,
+          {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(body)
+          }
+        );
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(`Chat reply complete failed (${res.status}): ${text}`);
+        }
+      }
       async heartbeat(capabilities) {
         const res = await fetch(
           `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/heartbeat`,
@@ -4166,6 +4235,24 @@ function createRelayService(api) {
   const COMPLETED_JOB_TTL_MS = 5 * 60 * 1e3;
   const COMPLETED_JOB_MAX_SIZE = 5e3;
   const processingReasoningJobs = /* @__PURE__ */ new Set();
+  const chatSessionQueues = /* @__PURE__ */ new Map();
+  function enqueueChat(sessionId, work) {
+    const prev = chatSessionQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.catch(() => {
+    }).then(async () => {
+      try {
+        await work();
+      } catch (err) {
+        api.logger.error(`Chat queue work failed: ${err}`);
+      }
+    });
+    chatSessionQueues.set(sessionId, next);
+    void next.then(() => {
+      if (chatSessionQueues.get(sessionId) === next) {
+        chatSessionQueues.delete(sessionId);
+      }
+    });
+  }
   function evictStaleCompletedJobs() {
     const cutoff = Date.now() - COMPLETED_JOB_TTL_MS;
     for (const [jobId, completedAt] of completedReasoningJobs) {
@@ -4322,6 +4409,34 @@ function createRelayService(api) {
     }
     return null;
   }
+  async function extractReplyForChatMessage(sessionKey, userMessageId, maxAttempts = 3) {
+    const marker = `[StageWhisper chat: ${userMessageId}]`;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+      const session = await api.runtime.subagent.getSessionMessages({
+        sessionKey,
+        limit: 100
+      });
+      const messages = session.messages;
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg["role"] !== "user") continue;
+        const text = extractContentFromMessage(msg) ?? "";
+        if (!text.includes(marker)) continue;
+        for (let j = i + 1; j < messages.length; j++) {
+          const next = messages[j];
+          const role = next["role"];
+          if (role === "assistant" || role === "model") {
+            return extractContentFromMessage(next);
+          }
+          if (role === "user") break;
+        }
+      }
+    }
+    return null;
+  }
   function decryptTaskFields(task, client) {
     const keypair = client.pluginKeypair;
     const desktopPub = client.desktopPublicKey;
@@ -4746,6 +4861,278 @@ function createRelayService(api) {
       api.logger.error(`Failed to post BYO reasoning result for ${job.job_id}: ${postErr}`);
     }
   }
+  function looksLikeBYOEnvelope(s) {
+    const trimmed = s.trimStart();
+    if (!trimmed.startsWith("{")) return false;
+    return trimmed.includes('"version"') && trimmed.includes('"sender_role"') && trimmed.includes('"ciphertext"');
+  }
+  function decryptChatPrompt(rawContent, client) {
+    const keypair = client.pluginKeypair;
+    const desktopPub = client.desktopPublicKey;
+    if (!keypair || !desktopPub) {
+      return { error: "missing_byo_keys" };
+    }
+    try {
+      const envelope = JSON.parse(rawContent);
+      const envelopeKey = keypair.deriveEnvelopeKey(desktopPub);
+      const plaintextBytes = open(envelopeKey, envelope);
+      return {
+        plaintext: new TextDecoder().decode(plaintextBytes),
+        envelopeKey
+      };
+    } catch (err) {
+      return { error: `decryption_error: ${err}` };
+    }
+  }
+  function sealChatReply(envelopeKey, sessionId, userMessageId, replyText) {
+    const envelope = seal(
+      envelopeKey,
+      "plugin",
+      sessionId,
+      `chat-reply:${userMessageId}`,
+      "task_content",
+      new TextEncoder().encode(replyText)
+    );
+    return JSON.stringify(envelope);
+  }
+  async function handleChatMessage(envelope, client) {
+    const userMessageId = envelope.user_message_id;
+    const sessionId = envelope.session_id;
+    const rawContent = envelope.content;
+    if (!userMessageId || !sessionId || !rawContent) {
+      api.logger.warn(
+        `Skipping chat message dispatch \u2014 missing fields (user_message_id=${userMessageId}, session_id=${sessionId})`
+      );
+      return;
+    }
+    api.logger.info(
+      `Received chat message: ${userMessageId} (session: ${sessionId})`
+    );
+    let plaintextContent = rawContent;
+    let envelopeKey = null;
+    if (looksLikeBYOEnvelope(rawContent)) {
+      const decryptResult = decryptChatPrompt(rawContent, client);
+      if ("error" in decryptResult) {
+        api.logger.error(
+          `Chat ${userMessageId} BYO decrypt failed: ${decryptResult.error}`
+        );
+        try {
+          await client.postChatReply(
+            userMessageId,
+            "(BYO decrypt failed)",
+            {
+              status: "errored",
+              errorCode: decryptResult.error.startsWith("missing_") ? "missing_byo_keys" : "decryption_error",
+              errorMessage: decryptResult.error
+            }
+          );
+        } catch (postErr) {
+          api.logger.error(`Failed to report BYO error: ${postErr}`);
+        }
+        return;
+      }
+      plaintextContent = decryptResult.plaintext;
+      envelopeKey = decryptResult.envelopeKey;
+    }
+    const sessionKey = buildAgentSessionKey({
+      agentId: "default",
+      channel: "stagewhisper",
+      peer: { kind: "direct", id: `sw-chat-${sessionId}` }
+    });
+    const finalizeReply = async (replyText, options) => {
+      const outbound = envelopeKey ? sealChatReply(envelopeKey, sessionId, userMessageId, replyText) : replyText;
+      await client.postChatReply(userMessageId, outbound, options);
+    };
+    const decoratedPrompt = `${plaintextContent}
+
+[StageWhisper chat: ${userMessageId}]`;
+    if (envelopeKey === null) {
+      await handleChatMessageStreaming(
+        client,
+        sessionKey,
+        userMessageId,
+        decoratedPrompt
+      );
+      return;
+    }
+    try {
+      const result = await api.runtime.subagent.run({
+        sessionKey,
+        message: decoratedPrompt,
+        deliver: true,
+        idempotencyKey: `sw-chat-${userMessageId}`
+      });
+      const waitResult = await api.runtime.subagent.waitForRun({
+        runId: result.runId,
+        timeoutMs: 12e4
+      });
+      if (waitResult.status === "ok") {
+        const reply = await extractReplyForChatMessage(sessionKey, userMessageId);
+        if (reply) {
+          await finalizeReply(reply);
+          api.logger.info(`Chat message ${userMessageId} replied`);
+        } else {
+          api.logger.warn(
+            `Chat message ${userMessageId} completed but no reply found`
+          );
+          await finalizeReply("(no reply produced)", {
+            status: "errored",
+            errorCode: "no_reply",
+            errorMessage: "Agent run produced no reply"
+          });
+        }
+      } else {
+        api.logger.error(
+          `Agent run failed for chat message ${userMessageId}: ${waitResult.error}`
+        );
+        await finalizeReply("(agent run failed)", {
+          status: "errored",
+          errorCode: "agent_error",
+          errorMessage: waitResult.error ?? "Agent run failed"
+        });
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      api.logger.error(`Failed to process chat message ${userMessageId}: ${errMsg}`);
+      try {
+        await finalizeReply("(execution error)", {
+          status: "errored",
+          errorCode: "execution_error",
+          errorMessage: errMsg
+        });
+      } catch (postErr) {
+        api.logger.error(`Failed to report chat failure: ${postErr}`);
+      }
+    }
+  }
+  async function handleChatMessageStreaming(client, sessionKey, userMessageId, decoratedPrompt) {
+    let assistantId;
+    try {
+      const started = await client.startChatReply(userMessageId);
+      assistantId = started.id;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      api.logger.error(
+        `Chat ${userMessageId} failed to start streaming reply: ${errMsg}`
+      );
+      try {
+        await client.postChatReply(userMessageId, "(streaming start failed)", {
+          status: "errored",
+          errorCode: "stream_start_failed",
+          errorMessage: errMsg
+        });
+      } catch (postErr) {
+        api.logger.error(
+          `Chat ${userMessageId} fallback errored post failed: ${postErr}`
+        );
+      }
+      return;
+    }
+    let ackedText = "";
+    const sendDelta = async (full) => {
+      if (!full || full.length <= ackedText.length) return;
+      if (!full.startsWith(ackedText)) return;
+      const diff = full.slice(ackedText.length);
+      if (!diff) return;
+      try {
+        await client.postChatReplyDelta(assistantId, diff);
+        ackedText = full;
+      } catch (err) {
+        api.logger.warn(`Chat ${userMessageId} delta post failed: ${err}`);
+      }
+    };
+    const finalizeErrored = async (content, errorCode, errorMessage) => {
+      try {
+        await client.completeChatReply(assistantId, {
+          status: "errored",
+          content: content || void 0,
+          errorCode,
+          errorMessage
+        });
+      } catch (postErr) {
+        api.logger.error(
+          `Chat ${userMessageId} finalize errored failed: ${postErr}`
+        );
+      }
+    };
+    let pollDone = false;
+    const pollInterval = 400;
+    const pollLoop = (async () => {
+      while (!pollDone) {
+        await new Promise((r) => setTimeout(r, pollInterval));
+        if (pollDone) break;
+        try {
+          const partial = await extractReplyForChatMessage(
+            sessionKey,
+            userMessageId,
+            1
+          );
+          if (partial) await sendDelta(partial);
+        } catch (err) {
+          api.logger.warn(`Chat ${userMessageId} poll failed: ${err}`);
+        }
+      }
+    })();
+    try {
+      const result = await api.runtime.subagent.run({
+        sessionKey,
+        message: decoratedPrompt,
+        deliver: true,
+        idempotencyKey: `sw-chat-${userMessageId}`
+      });
+      const waitResult = await api.runtime.subagent.waitForRun({
+        runId: result.runId,
+        timeoutMs: 12e4
+      });
+      pollDone = true;
+      await pollLoop;
+      const finalReply = await extractReplyForChatMessage(
+        sessionKey,
+        userMessageId
+      );
+      if (waitResult.status !== "ok") {
+        api.logger.error(
+          `Agent run failed for chat ${userMessageId}: ${waitResult.error}`
+        );
+        await finalizeErrored(
+          finalReply ?? ackedText,
+          "agent_error",
+          waitResult.error ?? "Agent run failed"
+        );
+        return;
+      }
+      if (!finalReply) {
+        api.logger.warn(
+          `Chat message ${userMessageId} completed but no reply found`
+        );
+        await finalizeErrored(
+          ackedText,
+          "no_reply",
+          "Agent run produced no reply"
+        );
+        return;
+      }
+      try {
+        await client.completeChatReply(assistantId, { content: finalReply });
+        api.logger.info(`Chat message ${userMessageId} streamed`);
+      } catch (completeErr) {
+        const errMsg = completeErr instanceof Error ? completeErr.message : String(completeErr);
+        api.logger.error(
+          `Chat ${userMessageId} complete failed: ${errMsg}`
+        );
+        await finalizeErrored(finalReply, "complete_failed", errMsg);
+      }
+    } catch (err) {
+      pollDone = true;
+      try {
+        await pollLoop;
+      } catch {
+      }
+      const errMsg = err instanceof Error ? err.message : String(err);
+      api.logger.error(`Failed to stream chat ${userMessageId}: ${errMsg}`);
+      await finalizeErrored(ackedText, "execution_error", errMsg);
+    }
+  }
   async function handleReasoningJob(job, client) {
     const hydrated = await hydrateReasoningJobEnvelope(
       job,
@@ -4914,6 +5301,16 @@ function createRelayService(api) {
               handleReasoningJob(envelope, client).catch(
                 (err) => api.logger.error(`Error handling reasoning job: ${err}`)
               );
+            } else if (envelope.event_type === "chat_message_dispatched") {
+              const chatEnv = envelope;
+              enqueueChat(
+                chatEnv.session_id,
+                () => handleChatMessage(chatEnv, client)
+              );
+            } else if (envelope.event_type !== void 0 && envelope.id === void 0) {
+              api.logger.warn(
+                `Ignoring unknown relay envelope: ${JSON.stringify(envelope.event_type)}`
+              );
             } else {
               const task = envelope;
               await handleTask(task, client);

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "stagewhisper",
   "name": "StageWhisper",
   "description": "Turn live call moments into assistant tasks via StageWhisper",
-  "version": "0.57.0",
+  "version": "0.60.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stagewhisper/stagewhisper",
-  "version": "0.57.0",
+  "version": "0.60.0",
   "type": "module",
   "description": "OpenClaw channel plugin that connects StageWhisper live calls to your AI assistant",
   "license": "MIT",