@stagewhisper/stagewhisper 0.59.0 → 0.60.0

package/dist/index.js

@@ -119,6 +119,54 @@ var init_client = __esm({
           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`,
@@ -4898,6 +4946,15 @@ function createRelayService(api) {
     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,
@@ -4948,6 +5005,134 @@ function createRelayService(api) {
       }
     }
   }
+  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,

package/openclaw.plugin.json

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

package/package.json

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