@stagewhisper/stagewhisper 0.37.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.37.0",
+  "version": "0.38.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stagewhisper/stagewhisper",
-  "version": "0.37.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/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(
@@ -136,12 +136,10 @@ 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) {
@@ -149,58 +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(),
+    });
+
+    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 +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}`);
           }
         }
       }