@stagewhisper/stagewhisper 0.38.0 → 0.40.0

package/openclaw.plugin.json

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

package/package.json

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

package/src/channel.ts

@@ -4,7 +4,6 @@ import {
   DEFAULT_ACCOUNT_ID,
 } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { StageWhisperClient } from "./client.js";
 
 export type StageWhisperAccount = {
   accountId: string | null;
@@ -163,23 +162,15 @@ export const stagewhisperPlugin = createChatChannelPlugin<StageWhisperAccount>(
       attachedResults: {
         channel: "stagewhisper",
         sendText: async (ctx) => {
-          const account = resolveAccount(ctx.cfg, ctx.accountId);
-          const client = new StageWhisperClient(
-            account.apiBaseUrl,
-            account.integrationId,
-            account.relayToken,
-          );
-
-          const target = (ctx as Record<string, unknown>).to as string | undefined;
-          const threadId = ctx.threadId as string | undefined;
-          const raw = target ?? threadId ?? "";
-          const taskId = raw.replace(/^sw-task-/, "");
-          if (!taskId) {
-            return { messageId: `sw-noop-${Date.now()}`, ok: true };
+          const target = (ctx as Record<string, unknown>).to as string | undefined ?? "";
+          if (target.startsWith("sw-session-")) {
+            return { messageId: `sw-relay-ack-${Date.now()}`, ok: true };
           }
-
-          await client.postReply(taskId, ctx.text);
-          return { messageId: `sw-reply-${taskId}-${Date.now()}`, ok: true };
+          console.warn(
+            `[stagewhisper] sendText called for unrecognised target "${target}"; ` +
+            `StageWhisper channel is inbound-only — task replies are routed by the relay service`,
+          );
+          return { messageId: `sw-dropped-${Date.now()}`, ok: false };
         },
       },
     },

package/src/service.ts

@@ -90,6 +90,27 @@ export function createRelayService(api: OpenClawPluginApi) {
     await client.updateTaskStatus(task.id, status);
   }
 
+  function extractContentFromMessage(
+    msg: Record<string, unknown>,
+  ): string | null {
+    const content = msg["content"];
+    if (typeof content === "string") return content;
+
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (
+          typeof part === "object" &&
+          part !== null &&
+          (part as Record<string, unknown>)["type"] === "text" &&
+          typeof (part as Record<string, unknown>)["text"] === "string"
+        ) {
+          return (part as Record<string, unknown>)["text"] as string;
+        }
+      }
+    }
+    return null;
+  }
+
   function extractAssistantReply(
     messages: unknown[],
   ): string | null {
@@ -98,20 +119,39 @@ export function createRelayService(api: OpenClawPluginApi) {
       if (!msg) continue;
       const role = msg["role"];
       if (role !== "assistant" && role !== "model") continue;
+      return extractContentFromMessage(msg);
+    }
+    return null;
+  }
 
-      const content = msg["content"];
-      if (typeof content === "string") return content;
-
-      if (Array.isArray(content)) {
-        for (const part of content) {
-          if (
-            typeof part === "object" &&
-            part !== null &&
-            (part as Record<string, unknown>)["type"] === "text" &&
-            typeof (part as Record<string, unknown>)["text"] === "string"
-          ) {
-            return (part as Record<string, unknown>)["text"] as string;
+  async function extractReplyForTask(
+    sessionKey: string,
+    taskId: string,
+    maxAttempts: number = 3,
+  ): Promise<string | null> {
+    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: 50,
+      });
+      const messages = session.messages as Record<string, unknown>[];
+
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg["role"] !== "user") continue;
+        const text = extractContentFromMessage(msg) ?? "";
+        if (!text.includes(`StageWhisper task: ${taskId}`)) continue;
+
+        for (let j = i + 1; j < messages.length; j++) {
+          const reply = messages[j];
+          const role = reply["role"];
+          if (role === "assistant" || role === "model") {
+            return extractContentFromMessage(reply);
           }
+          if (role === "user") break;
         }
       }
     }
@@ -143,14 +183,16 @@ export function createRelayService(api: OpenClawPluginApi) {
     try {
       await updateStatus(client, task, "delivered");
     } catch (err) {
-      api.logger.warn(`Failed to mark task as delivered: ${err}`);
+      api.logger.warn(`Failed to mark task as delivered, skipping to prevent duplicates: ${err}`);
+      return;
     }
 
     const messageContent = buildTaskMessage(task);
+    const peerId = `sw-session-${task.session_id}`;
     const sessionKey = buildAgentSessionKey({
       agentId: "default",
       channel: "stagewhisper",
-      peer: { kind: "direct", id: `sw-task-${task.id}` },
+      peer: { kind: "direct", id: peerId },
     });
 
     const result = await api.runtime.subagent.run({
@@ -174,8 +216,14 @@ export function createRelayService(api: OpenClawPluginApi) {
       .waitForRun({ runId: result.runId, timeoutMs: 120_000 })
       .then(async (waitResult) => {
         if (waitResult.status === "ok") {
+          const reply = await extractReplyForTask(sessionKey, task.id);
+          if (reply) {
+            await client.postReply(task.id, reply);
+            api.logger.info(`Task ${task.id} completed with reply`);
+          } else {
+            api.logger.warn(`Task ${task.id} completed but no reply found`);
+          }
           await updateStatus(client, task, "completed").catch(() => {});
-          api.logger.info(`Task ${task.id} completed`);
         } else {
           api.logger.error(
             `Agent run failed for task ${task.id}: ${waitResult.error}`,
@@ -183,8 +231,9 @@ export function createRelayService(api: OpenClawPluginApi) {
           await updateStatus(client, task, "failed").catch(() => {});
         }
       })
-      .catch((err) => {
+      .catch(async (err) => {
         api.logger.error(`Failed to track task ${task.id}: ${err}`);
+        await updateStatus(client, task, "failed").catch(() => {});
       });
   }