@stagewhisper/stagewhisper 0.51.0 → 0.53.0

package/src/service.ts

@@ -1,952 +0,0 @@
-import type { OpenClawPluginApi, OpenClawPluginServiceContext } from "openclaw/plugin-sdk/core";
-import { buildAgentSessionKey } from "openclaw/plugin-sdk/core";
-import { randomUUID } from "node:crypto";
-import { StageWhisperClient } from "./client.js";
-import type { TaskPayload } from "./client.js";
-import type { StageWhisperAccount } from "./channel.js";
-import { resolveAccount } from "./channel.js";
-import { createHealthTracker } from "./health.js";
-import { executeReasoningJob, probeOpenResponses, type ReasoningJobEnvelope } from "./reasoning.js";
-import { isResponsesEndpointEnabled } from "./openresponses.js";
-import { IdentityKeypair, seal, open, type BYOEnvelope } from "./crypto.js";
-
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const RECONNECT_BASE_MS = 1_000;
-const RECONNECT_MAX_MS = 60_000;
-
-type ServiceState = {
-  running: boolean;
-  connected: boolean;
-  lastHeartbeat: Date | null;
-  reconnectAttempts: number;
-};
-
-export function createRelayService(api: OpenClawPluginApi) {
-  const state: ServiceState = {
-    running: false,
-    connected: false,
-    lastHeartbeat: null,
-    reconnectAttempts: 0,
-  };
-
-  let abortController: AbortController | null = null;
-  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  const health = createHealthTracker(null);
-
-  const completedReasoningJobs = new Map<string, number>();
-  const COMPLETED_JOB_TTL_MS = 5 * 60 * 1000; // 5 minutes
-  const COMPLETED_JOB_MAX_SIZE = 5000;
-  const processingReasoningJobs = new Set<string>();
-
-  function evictStaleCompletedJobs(): void {
-    const cutoff = Date.now() - COMPLETED_JOB_TTL_MS;
-    for (const [jobId, completedAt] of completedReasoningJobs) {
-      if (completedAt < cutoff) completedReasoningJobs.delete(jobId);
-    }
-    while (completedReasoningJobs.size > COMPLETED_JOB_MAX_SIZE) {
-      completedReasoningJobs.delete(completedReasoningJobs.keys().next().value!);
-    }
-  }
-
-  function resolveServiceAccount(): StageWhisperAccount {
-    try {
-      return resolveAccount(api.config);
-    } catch {
-      const pluginCfg = api.pluginConfig as Record<string, unknown>;
-      return {
-        accountId: null,
-        apiBaseUrl: (pluginCfg["apiBaseUrl"] as string) ?? "",
-        integrationId: (pluginCfg["integrationId"] as string) ?? "",
-        relayToken: (pluginCfg["relayToken"] as string) ?? "",
-        label: (pluginCfg["label"] as string) ?? "StageWhisper",
-        pluginSecretKeyB64: (pluginCfg["pluginSecretKey"] as string) ?? undefined,
-        desktopPublicKeyB64: (pluginCfg["desktopPublicKey"] as string) ?? undefined,
-      };
-    }
-  }
-
-  function buildTaskMessage(task: TaskPayload): string {
-    const lines: string[] = [];
-    lines.push(`**${task.title}**`);
-    lines.push("");
-    lines.push(task.request_text);
-
-    if (task.evidence_payload) {
-      const evidence = task.evidence_payload;
-      if (evidence["transcript_excerpt"]) {
-        lines.push("");
-        lines.push(`Context: ${evidence["transcript_excerpt"]}`);
-      }
-      if (evidence["signal_summary"]) {
-        lines.push(`Signal: ${evidence["signal_summary"]}`);
-      }
-      if (evidence["tone_summary"]) {
-        lines.push(`Tone: ${evidence["tone_summary"]}`);
-      }
-      if (evidence["playbook_label"]) {
-        lines.push(`Playbook: ${evidence["playbook_label"]}`);
-      }
-    }
-
-    lines.push("");
-    lines.push(`Action type: ${task.action_type}`);
-    lines.push(`StageWhisper task: ${task.id}`);
-    lines.push(`Session: ${task.session_id}`);
-
-    return lines.join("\n");
-  }
-
-  function isTestTask(task: TaskPayload): boolean {
-    return task.action_type === "connectivity_test";
-  }
-
-  async function updateStatus(
-    client: StageWhisperClient,
-    task: TaskPayload,
-    status: string,
-  ): Promise<void> {
-    if (isTestTask(task)) return;
-    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 {
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i] as Record<string, unknown> | undefined;
-      if (!msg) continue;
-      const role = msg["role"];
-      if (role !== "assistant" && role !== "model") continue;
-      return extractContentFromMessage(msg);
-    }
-    return null;
-  }
-
-  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;
-        }
-      }
-    }
-    return null;
-  }
-
-  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;
-  }
-
-  function decryptTaskFields(task: TaskPayload, client: StageWhisperClient): TaskPayload {
-    const keypair = client.pluginKeypair;
-    const desktopPub = client.desktopPublicKey;
-    if (!keypair || !desktopPub) return task;
-
-    const envelopeKey = keypair.deriveEnvelopeKey(desktopPub);
-    const decrypted = { ...task };
-    if (task.encrypted_title) {
-      try {
-        const envelope: BYOEnvelope = JSON.parse(task.encrypted_title);
-        const data = open(envelopeKey, envelope);
-        decrypted.title = new TextDecoder().decode(data);
-      } catch {
-        api.logger.warn(`Failed to decrypt task title for ${task.id}`);
-      }
-    }
-    if (task.encrypted_request) {
-      try {
-        const envelope: BYOEnvelope = JSON.parse(task.encrypted_request);
-        const data = open(envelopeKey, envelope);
-        decrypted.request_text = new TextDecoder().decode(data);
-      } catch {
-        api.logger.warn(`Failed to decrypt task request for ${task.id}`);
-      }
-    }
-    if (task.encrypted_evidence) {
-      try {
-        const envelope: BYOEnvelope = JSON.parse(task.encrypted_evidence);
-        const data = open(envelopeKey, envelope);
-        decrypted.evidence_payload = JSON.parse(new TextDecoder().decode(data));
-      } catch {
-        api.logger.warn(`Failed to decrypt task evidence for ${task.id}`);
-      }
-    }
-    return decrypted;
-  }
-
-  function encryptReply(content: string, client: StageWhisperClient, sessionId: string, taskId: string): string | undefined {
-    const keypair = client.pluginKeypair;
-    const desktopPub = client.desktopPublicKey;
-    if (!keypair || !desktopPub) return undefined;
-
-    const envelopeKey = keypair.deriveEnvelopeKey(desktopPub);
-    const envelope = seal(
-      envelopeKey,
-      "plugin",
-      sessionId,
-      taskId,
-      "task_reply",
-      new TextEncoder().encode(content),
-    );
-    return JSON.stringify(envelope);
-  }
-
-  async function handleNormalTask(task: TaskPayload, client: StageWhisperClient): Promise<void> {
-    let deliveredMarked = false;
-    for (let attempt = 0; attempt < 2; attempt++) {
-      try {
-        await updateStatus(client, task, "delivered");
-        deliveredMarked = true;
-        break;
-      } catch (err) {
-        api.logger.warn(`Failed to mark task as delivered (attempt ${attempt + 1}): ${err}`);
-        if (attempt === 0) await new Promise((r) => setTimeout(r, 1000));
-      }
-    }
-    if (!deliveredMarked) {
-      api.logger.warn(`Skipping task ${task.id} — could not mark delivered after retries`);
-      return;
-    }
-
-    const isByo = !!task.is_byo_encrypted;
-    const effectiveTask = isByo ? decryptTaskFields(task, client) : task;
-
-    const messageContent = buildTaskMessage(effectiveTask);
-    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: `sw-task-${task.id}`,
-    });
-
-    api.logger.info(`Task ${task.id} dispatched to agent session (runId: ${result.runId})`);
-
-    try {
-      await updateStatus(client, task, "running");
-    } catch (err) {
-      api.logger.warn(`Failed to mark task as running: ${err}`);
-    }
-
-    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) {
-            const encSummary = isByo ? encryptReply(reply, client, task.session_id, task.id) : undefined;
-            await client.postReply(task.id, isByo ? "[BYO Encrypted]" : reply, undefined, encSummary);
-            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(() => {});
-      });
-  }
-
-  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}` },
-    });
-
-    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}`);
-    }
-  }
-
-  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}`);
-      await updateStatus(client, task, "failed").catch(() => {});
-    }
-  }
-
-  async function handleCapabilityProbe(
-    job: ReasoningJobEnvelope,
-    client: StageWhisperClient,
-  ): Promise<boolean> {
-    const correlationId = job.correlation_id;
-    const displayModel = health.get().displayModel ?? null;
-    const prompt =
-      ((job.payload as Record<string, unknown>)?.prompt as string) ??
-      "Briefly describe your capabilities, personality, tools, expertise, goals, and constraints. Plain text, no JSON.";
-
-    const sessionKey = buildAgentSessionKey({
-      agentId: "default",
-      channel: "stagewhisper",
-      peer: { kind: "direct", id: `sw-probe-${job.job_id}` },
-    });
-
-    let callbackDelivered = false;
-
-    try {
-      const result = await api.runtime.subagent.run({
-        sessionKey,
-        message: prompt,
-        deliver: false,
-        idempotencyKey: `sw-probe-${job.job_id}`,
-      });
-
-      const waitResult = await api.runtime.subagent.waitForRun({
-        runId: result.runId,
-        timeoutMs: 35_000,
-      });
-
-      if (waitResult.status === "ok") {
-        const reply = await extractReplyWithRetry(sessionKey);
-
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "completed",
-            provider_run_id: result.runId,
-            model_ref: displayModel,
-            usage: null,
-            output: { raw_description: (reply ?? "").slice(0, 2000) },
-            error_code: null,
-            error_message: null,
-          },
-          correlationId,
-        );
-        callbackDelivered = true;
-        api.logger.info(`Capability probe ${job.job_id} completed`);
-      } else {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: result.runId,
-            model_ref: displayModel,
-            usage: null,
-            output: null,
-            error_code: "agent_error",
-            error_message: waitResult.error ?? "Agent run failed",
-          },
-          correlationId,
-        );
-        callbackDelivered = true;
-      }
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      api.logger.error(`Capability probe ${job.job_id} failed: ${errMsg}`);
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: null,
-            model_ref: displayModel,
-            usage: null,
-            output: null,
-            error_code: "execution_error",
-            error_message: errMsg,
-          },
-          correlationId,
-        );
-        callbackDelivered = true;
-      } catch (postErr) {
-        api.logger.error(`Failed to report probe failure: ${postErr}`);
-      }
-    }
-
-    return callbackDelivered;
-  }
-
-  async function handleBYOEncryptedJob(
-    job: ReasoningJobEnvelope,
-    client: StageWhisperClient,
-  ): Promise<void> {
-    const correlationId = job.correlation_id;
-    api.logger.info(
-      `Received BYO encrypted reasoning job: ${job.job_id}`,
-    );
-
-    const rawPayload = job.payload as Record<string, unknown>;
-    const envelope = rawPayload.envelope as Record<string, unknown> | undefined;
-    if (!envelope || !envelope.ciphertext) {
-      api.logger.error(`BYO job ${job.job_id} missing encrypted envelope`);
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: null,
-            model_ref: null,
-            usage: null,
-            output: null,
-            error_code: "missing_envelope",
-            error_message: "No encrypted envelope in BYO reasoning job",
-            byo_encrypted: true,
-          },
-          correlationId,
-        );
-      } catch (postErr) {
-        api.logger.error(`Failed to report BYO failure: ${postErr}`);
-      }
-      return;
-    }
-
-    const pluginKeypair = client.getPluginKeypair?.();
-    const desktopPublicKey = client.getDesktopPublicKey?.();
-
-    if (!pluginKeypair || !desktopPublicKey) {
-      api.logger.error(`BYO job ${job.job_id}: missing crypto keys`);
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: null,
-            model_ref: null,
-            usage: null,
-            output: null,
-            error_code: "missing_keys",
-            error_message: "Plugin or desktop keys not configured for BYO mode",
-            byo_encrypted: true,
-          },
-          correlationId,
-        );
-      } catch (postErr) {
-        api.logger.error(`Failed to report BYO key failure: ${postErr}`);
-      }
-      return;
-    }
-
-    let decryptedPayload: Record<string, unknown>;
-    const envelopeKey = pluginKeypair.deriveEnvelopeKey(desktopPublicKey);
-    try {
-      const byoEnvelope: BYOEnvelope = {
-        version: (envelope.version as string) ?? "static_v1",
-        sender_role: (envelope.sender_role as "desktop" | "plugin") ?? "desktop",
-        message_id: (envelope.message_id as string) ?? "",
-        session_id: (envelope.session_id as string) ?? "",
-        correlation_id: (envelope.correlation_id as string) ?? "",
-        content_type: (envelope.content_type as BYOEnvelope["content_type"]) ?? "reasoning_input",
-        nonce: envelope.nonce as string,
-        ciphertext: envelope.ciphertext as string,
-      };
-
-      const plaintext = open(envelopeKey, byoEnvelope);
-      decryptedPayload = JSON.parse(new TextDecoder().decode(plaintext));
-    } catch (err) {
-      api.logger.error(`BYO job ${job.job_id} decryption failed: ${err}`);
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: null,
-            model_ref: null,
-            usage: null,
-            output: null,
-            error_code: "decryption_error",
-            error_message: "Failed to decrypt BYO envelope",
-            byo_encrypted: true,
-          },
-          correlationId,
-        );
-      } catch (postErr) {
-        api.logger.error(`Failed to report BYO decryption failure: ${postErr}`);
-      }
-      return;
-    }
-
-    const plainJob: ReasoningJobEnvelope = {
-      ...job,
-      payload: decryptedPayload,
-      response_schema: decryptedPayload.response_schema as Record<string, unknown> ?? job.response_schema,
-    };
-
-    const displayModel = health.get().displayModel ?? null;
-    let result;
-    try {
-      result = await executeReasoningJob(api, plainJob, displayModel);
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      health.recordFailure(errMsg);
-      api.logger.error(`BYO reasoning job ${job.job_id} failed: ${errMsg}`);
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          {
-            job_id: job.job_id,
-            status: "failed",
-            provider_run_id: null,
-            model_ref: displayModel,
-            usage: null,
-            output: null,
-            error_code: "execution_error",
-            error_message: errMsg,
-            byo_encrypted: true,
-          },
-          correlationId,
-        );
-      } catch (postErr) {
-        api.logger.error(`Failed to report BYO reasoning failure: ${postErr}`);
-      }
-      return;
-    }
-
-    if (result.status === "completed") {
-      health.recordSuccess();
-    } else {
-      health.recordFailure(result.error_message ?? `reasoning ${result.status}`);
-    }
-
-    let encryptedResult: Record<string, unknown>;
-    try {
-      const resultJson = JSON.stringify(result.output ?? {});
-      const resultBytes = new TextEncoder().encode(resultJson);
-
-      const sessionId = (envelope.session_id as string) ?? "";
-      const resultCorrelationId = (envelope.correlation_id as string) ?? "";
-
-      const resultEnvelope = seal(
-        envelopeKey,
-        "plugin",
-        sessionId,
-        resultCorrelationId,
-        "reasoning_output",
-        resultBytes,
-      );
-
-      encryptedResult = {
-        byo_encrypted: true,
-        envelope: resultEnvelope,
-        job_id: job.job_id,
-        status: result.status,
-        usage: result.usage,
-        model_ref: result.model_ref,
-      };
-    } catch (err) {
-      api.logger.error(`BYO job ${job.job_id} result encryption failed: ${err}`);
-      encryptedResult = {
-        job_id: job.job_id,
-        status: "failed",
-        error_code: "encryption_error",
-        error_message: "Failed to encrypt result",
-        byo_encrypted: true,
-      };
-    }
-
-    try {
-      await client.postReasoningResult(
-        job.job_id,
-        encryptedResult,
-        correlationId,
-      );
-      completedReasoningJobs.set(job.job_id, Date.now());
-      api.logger.info(`BYO reasoning job ${job.job_id} completed (status: ${result.status})`);
-    } catch (postErr) {
-      api.logger.error(`Failed to post BYO reasoning result for ${job.job_id}: ${postErr}`);
-    }
-  }
-
-  async function handleReasoningJob(
-    job: ReasoningJobEnvelope,
-    client: StageWhisperClient,
-  ): Promise<void> {
-    const correlationId = job.correlation_id;
-    api.logger.info(
-      `Received reasoning job: ${job.job_id} (purpose: ${job.purpose}, correlation: ${correlationId ?? "none"})`,
-    );
-
-    if (completedReasoningJobs.has(job.job_id)) {
-      api.logger.info(`Skipping completed reasoning job: ${job.job_id}`);
-      return;
-    }
-    if (processingReasoningJobs.has(job.job_id)) {
-      api.logger.info(`Skipping in-flight reasoning job: ${job.job_id}`);
-      return;
-    }
-    processingReasoningJobs.add(job.job_id);
-
-    if (job.purpose === "capability_probe") {
-      try {
-        const delivered = await handleCapabilityProbe(job, client);
-        if (delivered) {
-          completedReasoningJobs.set(job.job_id, Date.now());
-        }
-      } finally {
-        processingReasoningJobs.delete(job.job_id);
-      }
-      return;
-    }
-
-    try {
-      const isBYOEncrypted =
-        job.payload &&
-        (job.payload as Record<string, unknown>).byo_encrypted === true;
-
-      if (isBYOEncrypted) {
-        await handleBYOEncryptedJob(job, client);
-        return;
-      }
-
-      const displayModel = health.get().displayModel ?? null;
-
-      let result;
-      try {
-        result = await executeReasoningJob(api, job, displayModel);
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        health.recordFailure(errMsg);
-        api.logger.error(`Reasoning job ${job.job_id} failed: ${errMsg}`);
-
-        try {
-          await client.postReasoningResult(
-            job.job_id,
-            {
-              job_id: job.job_id,
-              status: "failed",
-              provider_run_id: null,
-              model_ref: displayModel,
-              usage: null,
-              output: null,
-              error_code: "execution_error",
-              error_message: errMsg,
-            },
-            correlationId,
-          );
-        } catch (postErr) {
-          api.logger.error(`Failed to report reasoning failure: ${postErr}`);
-        }
-        return;
-      }
-
-      if (result.status === "completed") {
-        health.recordSuccess();
-      } else {
-        health.recordFailure(result.error_message ?? `reasoning ${result.status}`);
-      }
-
-      if (result.model_ref && result.model_ref !== displayModel) {
-        health.setModel(result.model_ref);
-      }
-
-      try {
-        await client.postReasoningResult(
-          job.job_id,
-          result as unknown as Record<string, unknown>,
-          correlationId,
-        );
-        completedReasoningJobs.set(job.job_id, Date.now());
-        if (completedReasoningJobs.size > COMPLETED_JOB_MAX_SIZE) {
-          evictStaleCompletedJobs();
-        }
-        api.logger.info(`Reasoning job ${job.job_id} completed (status: ${result.status})`);
-      } catch (postErr) {
-        api.logger.error(`Failed to post reasoning result for ${job.job_id}: ${postErr}`);
-      }
-    } finally {
-      processingReasoningJobs.delete(job.job_id);
-    }
-  }
-
-  function createClient(account: StageWhisperAccount): StageWhisperClient {
-    const client = new StageWhisperClient(
-      account.apiBaseUrl,
-      account.integrationId,
-      account.relayToken,
-    );
-    if (account.pluginSecretKeyB64) {
-      try {
-        const secretBytes = Uint8Array.from(atob(account.pluginSecretKeyB64), c => c.charCodeAt(0));
-        client.setPluginKeypair(IdentityKeypair.fromSecretBytes(secretBytes));
-      } catch (err) {
-        api.logger.warn(`Failed to load plugin keypair from config: ${err}`);
-      }
-    }
-    if (account.desktopPublicKeyB64) {
-      try {
-        client.setDesktopPublicKey(
-          IdentityKeypair.publicKeyFromBase64(account.desktopPublicKeyB64),
-        );
-      } catch (err) {
-        api.logger.warn(`Failed to load desktop public key from config: ${err}`);
-      }
-    }
-    return client;
-  }
-
-  async function connectStream(account: StageWhisperAccount): Promise<void> {
-    const client = createClient(account);
-
-    abortController = new AbortController();
-    const url = client.streamUrl();
-    api.logger.info(`Connecting to relay stream: ${url}`);
-
-    const res = await fetch(url, {
-      headers: client.streamHeaders(),
-      signal: abortController.signal,
-    });
-
-    if (!res.ok) {
-      throw new Error(`Stream connection failed (${res.status})`);
-    }
-
-    if (!res.body) {
-      throw new Error("Stream response has no body");
-    }
-
-    state.connected = true;
-    state.reconnectAttempts = 0;
-    health.setConnected();
-    api.logger.info("Connected to StageWhisper relay stream");
-
-    if (health.get().status !== "healthy") {
-      api.logger.info("Re-probing /v1/responses after reconnect...");
-      const probe = await probeOpenResponses(api);
-      if (probe.ok) {
-        health.recordSuccess();
-        if (probe.model) health.setModel(probe.model);
-        api.logger.info(`Local AI verified on reconnect — model: ${probe.model ?? "unknown"}`);
-      } else {
-        api.logger.warn(`Reconnect probe failed: ${probe.error}`);
-      }
-    }
-
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    try {
-      while (state.running) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-
-        for (const line of lines) {
-          if (!line.startsWith("data: ")) continue;
-          const jsonStr = line.slice(6).trim();
-          if (!jsonStr) continue;
-
-          try {
-            const envelope = JSON.parse(jsonStr) as Record<string, unknown>;
-            if (envelope.event_type === "reasoning_job") {
-              handleReasoningJob(envelope as unknown as ReasoningJobEnvelope, client).catch((err) =>
-                api.logger.error(`Error handling reasoning job: ${err}`),
-              );
-            } else {
-              const task = envelope as unknown as TaskPayload;
-              await handleTask(task, client);
-            }
-          } catch (err) {
-            api.logger.error(`Error processing event from stream: ${err}`);
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      state.connected = false;
-      health.setDisconnected();
-    }
-  }
-
-  function backoffMs(): number {
-    const ms = Math.min(RECONNECT_BASE_MS * Math.pow(2, state.reconnectAttempts), RECONNECT_MAX_MS);
-    return ms + Math.random() * 1000;
-  }
-
-  async function runLoop(account: StageWhisperAccount): Promise<void> {
-    while (state.running) {
-      try {
-        await connectStream(account);
-      } catch (err) {
-        if (!state.running) break;
-        health.setDisconnected();
-        state.reconnectAttempts++;
-        const delay = backoffMs();
-        api.logger.warn(
-          `Stream disconnected (attempt ${state.reconnectAttempts}), reconnecting in ${Math.round(delay)}ms: ${err}`,
-        );
-        await new Promise((r) => setTimeout(r, delay));
-      }
-    }
-  }
-
-  function startHeartbeat(account: StageWhisperAccount): void {
-    const client = createClient(account);
-
-    heartbeatTimer = setInterval(async () => {
-      try {
-        await client.heartbeat(health.toHeartbeatPayload());
-        state.lastHeartbeat = new Date();
-      } catch (err) {
-        api.logger.warn(`Heartbeat failed: ${err}`);
-      }
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-
-  return {
-    id: "stagewhisper-relay",
-
-    async start(_ctx: OpenClawPluginServiceContext): Promise<void> {
-      const account = resolveServiceAccount();
-      if (!account.apiBaseUrl || !account.integrationId || !account.relayToken) {
-        api.logger.info(
-          "StageWhisper not configured — skipping relay service. Pair first with: openclaw stagewhisper pair",
-        );
-        return;
-      }
-
-      api.logger.info(
-        `StageWhisper relay starting — backend: ${account.apiBaseUrl}, integration: ${account.integrationId}`,
-      );
-
-      state.running = true;
-
-      if (!isResponsesEndpointEnabled(api)) {
-        api.logger.warn(
-          "gateway.http.endpoints.responses.enabled is not true — reasoning jobs will fail with 404. " +
-            "Enable it in config and restart the gateway, or re-pair with: openclaw stagewhisper pair --code <CODE> --enable-responses",
-        );
-      }
-
-      api.logger.info("Probing /v1/responses to verify local AI connectivity...");
-      const probe = await probeOpenResponses(api);
-      if (probe.ok) {
-        health.recordSuccess();
-        if (probe.model) health.setModel(probe.model);
-        api.logger.info(`Local AI verified — model: ${probe.model ?? "unknown"}`);
-      } else {
-        health.recordFailure(probe.error ?? "probe_failed");
-        api.logger.warn(`Local AI probe failed: ${probe.error} — relay starts as unverified`);
-      }
-
-      startHeartbeat(account);
-      runLoop(account).catch((err) => {
-        api.logger.error(`Relay service crashed: ${err}`);
-      });
-      api.logger.info(`StageWhisper relay service started for ${account.label}`);
-    },
-
-    async stop(_ctx: OpenClawPluginServiceContext): Promise<void> {
-      state.running = false;
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-      }
-      if (abortController) {
-        abortController.abort();
-        abortController = null;
-      }
-      api.logger.info("StageWhisper relay service stopped");
-    },
-
-    getState(): ServiceState {
-      return { ...state };
-    },
-  };
-}