@stagewhisper/stagewhisper 0.37.0 → 0.39.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.37.0",
+  "version": "0.39.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stagewhisper/stagewhisper",
-  "version": "0.37.0",
+  "version": "0.39.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;
@@ -147,24 +146,31 @@ export const stagewhisperPlugin = createChatChannelPlugin<StageWhisperAccount>(
     threading: { topLevelReplyToMode: "reply" },
 
     outbound: {
-      base: { deliveryMode: "direct" },
+      base: {
+        deliveryMode: "direct",
+        resolveTarget: (params: {
+          cfg?: OpenClawConfig;
+          to?: string;
+          allowFrom?: string[];
+          accountId?: string | null;
+          mode?: string;
+        }) => {
+          if (!params.to) return { ok: false as const, error: new Error("No delivery target") };
+          return { ok: true as const, to: params.to };
+        },
+      },
       attachedResults: {
         channel: "stagewhisper",
         sendText: async (ctx) => {
-          const account = resolveAccount(ctx.cfg, ctx.accountId);
-          const client = new StageWhisperClient(
-            account.apiBaseUrl,
-            account.integrationId,
-            account.relayToken,
-          );
-
-          const taskId = ctx.threadId as string | undefined;
-          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

@@ -78,7 +78,7 @@ export function createRelayService(api: OpenClawPluginApi) {
   }
 
   function isTestTask(task: TaskPayload): boolean {
-    return task.action_type === "test";
+    return task.action_type === "connectivity_test";
   }
 
   async function updateStatus(
@@ -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;
         }
       }
     }
@@ -136,71 +176,121 @@ export function createRelayService(api: OpenClawPluginApi) {
     return null;
   }
 
-  async function handleTask(
+  async function handleNormalTask(
     task: TaskPayload,
     client: StageWhisperClient,
   ): Promise<void> {
-    api.logger.info(`Received task: ${task.title} (${task.id})`);
-
     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: peerId },
+    });
+
+    const result = await api.runtime.subagent.run({
+      sessionKey,
+      message: messageContent,
+      deliver: true,
+      idempotencyKey: randomUUID(),
+    });
+
+    api.logger.info(
+      `Task ${task.id} dispatched to agent session (runId: ${result.runId})`,
+    );
 
     try {
-      const sessionKey = buildAgentSessionKey({
-        agentId: "default",
-        channel: "stagewhisper",
-        peer: { kind: "direct", id: `sw-task-${task.id}` },
-      });
+      await updateStatus(client, task, "running");
+    } catch (err) {
+      api.logger.warn(`Failed to mark task as running: ${err}`);
+    }
 
-      const result = await api.runtime.subagent.run({
-        sessionKey,
-        message: messageContent,
-        deliver: false,
-        idempotencyKey: randomUUID(),
+    api.runtime.subagent
+      .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(() => {});
+        } else {
+          api.logger.error(
+            `Agent run failed for task ${task.id}: ${waitResult.error}`,
+          );
+          await updateStatus(client, task, "failed").catch(() => {});
+        }
+      })
+      .catch(async (err) => {
+        api.logger.error(`Failed to track task ${task.id}: ${err}`);
+        await updateStatus(client, task, "failed").catch(() => {});
       });
+  }
 
-      api.logger.info(
-        `Task ${task.id} dispatched to agent session (runId: ${result.runId})`,
-      );
+  async function handleTestTask(
+    task: TaskPayload,
+    client: StageWhisperClient,
+  ): Promise<void> {
+    const messageContent = buildTaskMessage(task);
+    const sessionKey = buildAgentSessionKey({
+      agentId: "default",
+      channel: "stagewhisper",
+      peer: { kind: "direct", id: `sw-test-${task.id}` },
+    });
 
-      try {
-        await updateStatus(client, task, "running");
-      } catch (err) {
-        api.logger.warn(`Failed to mark task as running: ${err}`);
+    const result = await api.runtime.subagent.run({
+      sessionKey,
+      message: messageContent,
+      deliver: false,
+      idempotencyKey: randomUUID(),
+    });
+
+    api.logger.info(
+      `Test task ${task.id} dispatched (runId: ${result.runId})`,
+    );
+
+    const waitResult = await api.runtime.subagent.waitForRun({
+      runId: result.runId,
+      timeoutMs: 120_000,
+    });
+
+    if (waitResult.status === "ok") {
+      const reply = await extractReplyWithRetry(sessionKey);
+      if (reply) {
+        await client.testReply(task.id, reply);
+        api.logger.info(`Test task ${task.id} completed with reply`);
+      } else {
+        api.logger.warn(`Test task ${task.id} completed but no reply found`);
+        await client.testReply(task.id, "(no reply extracted)");
       }
+    } else {
+      api.logger.error(
+        `Agent run failed for test task ${task.id}: ${waitResult.error}`,
+      );
+    }
+  }
 
-      const waitResult = await api.runtime.subagent.waitForRun({
-        runId: result.runId,
-        timeoutMs: 120_000,
-      });
+  async function handleTask(
+    task: TaskPayload,
+    client: StageWhisperClient,
+  ): Promise<void> {
+    api.logger.info(`Received task: ${task.title} (${task.id})`);
 
-      if (waitResult.status === "ok") {
-        const reply = await extractReplyWithRetry(sessionKey);
-        if (reply) {
-          if (isTestTask(task)) {
-            await client.testReply(task.id, reply);
-          } else {
-            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`);
-          if (isTestTask(task)) {
-            await client.testReply(task.id, "(no reply extracted)");
-          } else {
-            await updateStatus(client, task, "completed").catch(() => {});
-          }
-        }
+    try {
+      if (isTestTask(task)) {
+        await handleTestTask(task, client);
       } else {
-        api.logger.error(
-          `Agent run failed for task ${task.id}: ${waitResult.error}`,
-        );
-        await updateStatus(client, task, "failed").catch(() => {});
+        await handleNormalTask(task, client);
       }
     } catch (err) {
       api.logger.error(`Failed to process task ${task.id}: ${err}`);
@@ -256,11 +346,9 @@ export function createRelayService(api: OpenClawPluginApi) {
 
           try {
             const task = JSON.parse(jsonStr) as TaskPayload;
-            handleTask(task, client).catch((err) => {
-              api.logger.error(`Unhandled error processing task: ${err}`);
-            });
-          } catch (parseErr) {
-            api.logger.warn(`Failed to parse stream event: ${parseErr}`);
+            await handleTask(task, client);
+          } catch (err) {
+            api.logger.error(`Error processing task from stream: ${err}`);
           }
         }
       }