@stagewhisper/stagewhisper 0.32.0 → 0.35.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.32.0",
+  "version": "0.35.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

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

package/plugin-main.ts

@@ -56,12 +56,13 @@ export default definePluginEntry({
                 plugins["entries"] = entries;
                 (cfg as Record<string, unknown>)["plugins"] = plugins;
 
-                const channels = ((cfg as Record<string, unknown>)["channels"] as Record<string, unknown>) ?? {};
-                channels["stagewhisper"] = {
-                  integrationId: result.integration_id,
-                  apiBaseUrl: opts.apiUrl,
-                };
-                (cfg as Record<string, unknown>)["channels"] = channels;
+                const channels = (cfg as Record<string, unknown>)["channels"] as Record<string, unknown> | undefined;
+                if (channels?.["stagewhisper"]) {
+                  delete channels["stagewhisper"];
+                  if (Object.keys(channels).length === 0) {
+                    delete (cfg as Record<string, unknown>)["channels"];
+                  }
+                }
 
                 await api.runtime.config.writeConfigFile(cfg);
 
@@ -120,7 +121,7 @@ export default definePluginEntry({
             if (!configured) {
               console.log("\nStageWhisper: not paired\n");
               console.log(
-                "  Run: openclaw stagewhisper pair --code <CODE>\n",
+                "  Run: openclaw stagewhisper pair --code <CODE> [--api-url <URL>]\n",
               );
               console.log(
                 "  Get the pairing code from StageWhisper desktop: Settings → Assistant → Generate Pairing Code\n",

package/src/service.ts

@@ -77,6 +77,32 @@ export function createRelayService(api: OpenClawPluginApi) {
     return lines.join("\n");
   }
 
+  function isTestTask(task: TaskPayload): boolean {
+    return task.action_type === "test";
+  }
+
+  async function updateStatus(
+    client: StageWhisperClient,
+    task: TaskPayload,
+    status: string,
+  ): Promise<void> {
+    if (isTestTask(task)) return;
+    await client.updateTaskStatus(task.id, status);
+  }
+
+  function extractAssistantReply(
+    messages: unknown[],
+  ): string | null {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i] as Record<string, unknown> | undefined;
+      if (!msg) continue;
+      if (msg["role"] === "assistant" && typeof msg["content"] === "string") {
+        return msg["content"];
+      }
+    }
+    return null;
+  }
+
   async function handleTask(
     task: TaskPayload,
     client: StageWhisperClient,
@@ -84,7 +110,7 @@ export function createRelayService(api: OpenClawPluginApi) {
     api.logger.info(`Received task: ${task.title} (${task.id})`);
 
     try {
-      await client.updateTaskStatus(task.id, "delivered");
+      await updateStatus(client, task, "delivered");
     } catch (err) {
       api.logger.warn(`Failed to mark task as delivered: ${err}`);
     }
@@ -95,23 +121,56 @@ export function createRelayService(api: OpenClawPluginApi) {
       const sessionKey = buildAgentSessionKey({
         agentId: "default",
         channel: "stagewhisper",
-        peer: { kind: "direct", id: `sw-session-${task.session_id}` },
+        peer: { kind: "direct", id: `sw-task-${task.id}` },
       });
 
       const result = await api.runtime.subagent.run({
         sessionKey,
         message: messageContent,
-        deliver: true,
+        deliver: false,
         idempotencyKey: randomUUID(),
       });
 
       api.logger.info(
         `Task ${task.id} dispatched to agent session (runId: ${result.runId})`,
       );
-      await client.updateTaskStatus(task.id, "running");
+
+      try {
+        await updateStatus(client, task, "running");
+      } catch (err) {
+        api.logger.warn(`Failed to mark task as running: ${err}`);
+      }
+
+      const waitResult = await api.runtime.subagent.waitForRun({
+        runId: result.runId,
+        timeoutMs: 120_000,
+      });
+
+      if (waitResult.status === "ok") {
+        const session = await api.runtime.subagent.getSessionMessages({
+          sessionKey,
+          limit: 20,
+        });
+
+        const reply = extractAssistantReply(session.messages);
+        if (reply) {
+          if (!isTestTask(task)) {
+            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 assistant reply found`);
+          await updateStatus(client, task, "completed").catch(() => {});
+        }
+      } else {
+        api.logger.error(
+          `Agent run failed for task ${task.id}: ${waitResult.error}`,
+        );
+        await updateStatus(client, task, "failed").catch(() => {});
+      }
     } catch (err) {
-      api.logger.error(`Failed to dispatch task to agent: ${err}`);
-      await client.updateTaskStatus(task.id, "failed").catch(() => {});
+      api.logger.error(`Failed to process task ${task.id}: ${err}`);
+      await updateStatus(client, task, "failed").catch(() => {});
     }
   }
 
@@ -163,7 +222,9 @@ export function createRelayService(api: OpenClawPluginApi) {
 
           try {
             const task = JSON.parse(jsonStr) as TaskPayload;
-            await handleTask(task, client);
+            handleTask(task, client).catch((err) => {
+              api.logger.error(`Unhandled error processing task: ${err}`);
+            });
           } catch (parseErr) {
             api.logger.warn(`Failed to parse stream event: ${parseErr}`);
           }