@stagewhisper/stagewhisper 0.31.0 → 0.33.0

package/openclaw.plugin.json

@@ -1,9 +1,8 @@
 {
   "id": "stagewhisper",
-  "kind": "channel",
   "name": "StageWhisper",
   "description": "Turn live call moments into assistant tasks via StageWhisper",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@stagewhisper/stagewhisper",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "type": "module",
   "description": "OpenClaw channel plugin that connects StageWhisper live calls to your AI assistant",
   "license": "MIT",
   "files": [
     "index.ts",
     "plugin-main.ts",
-    "setup-entry.ts",
     "api.ts",
     "src",
     "openclaw.plugin.json",
@@ -22,7 +21,6 @@
     "extensions": [
       "./index.ts"
     ],
-    "setupEntry": "./setup-entry.ts",
     "channel": {
       "id": "stagewhisper",
       "label": "StageWhisper",

package/plugin-main.ts

@@ -1,16 +1,14 @@
-import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { stagewhisperPlugin } from "./src/channel.js";
 import { setRuntime } from "./src/runtime.js";
 import { createRelayService } from "./src/service.js";
 
-export default defineChannelPluginEntry({
+export default definePluginEntry({
   id: "stagewhisper",
   name: "StageWhisper",
   description: "Turn live call moments into assistant tasks via StageWhisper",
-  plugin: stagewhisperPlugin,
-  setRuntime,
-  registerFull(api) {
-    const service = createRelayService(api);
+  register(api) {
+    api.registerChannel({ plugin: stagewhisperPlugin });
 
     api.registerCli(
       ({ program }) => {
@@ -122,7 +120,7 @@ export default defineChannelPluginEntry({
             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",
@@ -155,6 +153,10 @@ export default defineChannelPluginEntry({
       { commands: ["stagewhisper"] },
     );
 
+    if (api.registrationMode !== "full") return;
+
+    setRuntime(api.runtime);
+    const service = createRelayService(api);
     api.registerService(service);
   },
 });

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}`);
           }

package/setup-entry.ts

@@ -1,4 +0,0 @@
-import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
-import { stagewhisperPlugin } from "./src/channel.js";
-
-export default defineSetupPluginEntry(stagewhisperPlugin);