@stagewhisper/stagewhisper 0.36.0 → 0.38.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.36.0",
+  "version": "0.38.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

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

package/src/channel.ts

@@ -147,7 +147,19 @@ 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) => {
@@ -158,7 +170,10 @@ export const stagewhisperPlugin = createChatChannelPlugin<StageWhisperAccount>(
             account.relayToken,
           );
 
-          const taskId = ctx.threadId as string | undefined;
+          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 };
           }

package/src/client.ts

@@ -118,4 +118,19 @@ export class StageWhisperClient {
   streamHeaders(): Record<string, string> {
     return { Authorization: `Bearer ${this.relayToken}` };
   }
+
+  async testReply(testId: string, content: string): Promise<void> {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/test-reply`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ test_id: testId, content }),
+      },
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Test reply failed (${res.status}): ${text}`);
+    }
+  }
 }

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(
@@ -96,19 +96,50 @@ export function createRelayService(api: OpenClawPluginApi) {
     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"];
+      const role = msg["role"];
+      if (role !== "assistant" && role !== "model") continue;
+
+      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;
   }
 
-  async function handleTask(
+  async function extractReplyWithRetry(
+    sessionKey: 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: 20,
+      });
+      const reply = extractAssistantReply(session.messages);
+      if (reply) return reply;
+    }
+    return null;
+  }
+
+  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) {
@@ -116,57 +147,101 @@ export function createRelayService(api: OpenClawPluginApi) {
     }
 
     const messageContent = buildTaskMessage(task);
+    const sessionKey = buildAgentSessionKey({
+      agentId: "default",
+      channel: "stagewhisper",
+      peer: { kind: "direct", id: `sw-task-${task.id}` },
+    });
+
+    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") {
+          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}`,
+          );
+          await updateStatus(client, task, "failed").catch(() => {});
+        }
+      })
+      .catch((err) => {
+        api.logger.error(`Failed to track task ${task.id}: ${err}`);
       });
+  }
 
-      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(),
+    });
 
-      const waitResult = await api.runtime.subagent.waitForRun({
-        runId: result.runId,
-        timeoutMs: 120_000,
-      });
+    api.logger.info(
+      `Test task ${task.id} dispatched (runId: ${result.runId})`,
+    );
 
-      if (waitResult.status === "ok") {
-        const session = await api.runtime.subagent.getSessionMessages({
-          sessionKey,
-          limit: 20,
-        });
+    const waitResult = await api.runtime.subagent.waitForRun({
+      runId: result.runId,
+      timeoutMs: 120_000,
+    });
 
-        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(() => {});
-        }
+    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.error(
-          `Agent run failed for task ${task.id}: ${waitResult.error}`,
-        );
-        await updateStatus(client, task, "failed").catch(() => {});
+        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}`,
+      );
+    }
+  }
+
+  async function handleTask(
+    task: TaskPayload,
+    client: StageWhisperClient,
+  ): Promise<void> {
+    api.logger.info(`Received task: ${task.title} (${task.id})`);
+
+    try {
+      if (isTestTask(task)) {
+        await handleTestTask(task, client);
+      } else {
+        await handleNormalTask(task, client);
       }
     } catch (err) {
       api.logger.error(`Failed to process task ${task.id}: ${err}`);
@@ -222,11 +297,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}`);
           }
         }
       }