@stagewhisper/stagewhisper 0.40.0 → 0.43.0

package/src/reasoning.ts

@@ -0,0 +1,198 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import {
+  callOpenResponses,
+  OpenResponsesError,
+  type OpenResponsesCreateResponseRequestBody,
+  type OpenResponsesResponseResource,
+} from "./openresponses.js";
+
+export type ProbeResult = {
+  ok: boolean;
+  model: string | null;
+  error: string | null;
+};
+
+export async function probeOpenResponses(
+  api: OpenClawPluginApi,
+): Promise<ProbeResult> {
+  const body: OpenResponsesCreateResponseRequestBody = {
+    model: "default",
+    input: "Reply with exactly: OK",
+    max_output_tokens: 16,
+    temperature: 0,
+  };
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 15_000);
+
+  try {
+    const result = await callOpenResponses(api, body, controller.signal, undefined);
+    const model = (result as Record<string, unknown>).model as string ?? null;
+    return { ok: true, model, error: null };
+  } catch (err) {
+    return {
+      ok: false,
+      model: null,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export type ReasoningJobEnvelope = {
+  event_type: "reasoning_job";
+  job_id: string;
+  purpose: string;
+  deadline_at: string;
+  idempotency_key: string;
+  schema_version: number;
+  response_schema: Record<string, unknown>;
+  payload: Record<string, unknown>;
+  model?: string;
+  correlation_id?: string;
+};
+
+export type ReasoningJobResult = {
+  job_id: string;
+  status: "completed" | "failed" | "timed_out";
+  provider_run_id: string | null;
+  model_ref: string | null;
+  usage: { input_tokens: number; output_tokens: number } | null;
+  output: Record<string, unknown> | null;
+  error_code: string | null;
+  error_message: string | null;
+};
+
+function extractTextOutput(result: OpenResponsesResponseResource): string | null {
+  const output = result.output;
+  if (!Array.isArray(output)) return null;
+  for (const item of output) {
+    if (item.type !== "message") continue;
+    const content = (item as Record<string, unknown>).content;
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      const p = part as Record<string, unknown>;
+      if (p.type === "output_text" && typeof p.text === "string") {
+        return p.text;
+      }
+    }
+  }
+  return null;
+}
+
+export async function executeReasoningJob(
+  api: OpenClawPluginApi,
+  job: ReasoningJobEnvelope,
+  displayModel: string | null,
+): Promise<ReasoningJobResult> {
+  const parsedDeadline = new Date(job.deadline_at).getTime();
+  const deadlineMs = Number.isFinite(parsedDeadline)
+    ? parsedDeadline - Date.now()
+    : -1;
+  if (deadlineMs <= 0) {
+    return {
+      job_id: job.job_id,
+      status: "timed_out",
+      provider_run_id: null,
+      model_ref: displayModel,
+      usage: null,
+      output: null,
+      error_code: "deadline_expired_before_start",
+      error_message: "Job deadline had already passed when execution began",
+    };
+  }
+
+  const model = job.model ?? displayModel ?? "default";
+  const correlationId = job.correlation_id;
+
+  const requestBody: OpenResponsesCreateResponseRequestBody = {
+    model,
+    input: JSON.stringify(job.payload),
+    instructions: (job.payload.system_instruction as string) ?? undefined,
+    text: {
+      format: {
+        type: "json_schema",
+        name: `reasoning_${job.purpose}`,
+        schema: job.response_schema,
+        strict: true,
+      },
+    },
+    max_output_tokens: 4096,
+    temperature: 0.2,
+  };
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), deadlineMs);
+
+  try {
+    const result = await callOpenResponses(api, requestBody, controller.signal, correlationId);
+    const textOutput = extractTextOutput(result);
+
+    let parsed: Record<string, unknown> | null = null;
+    if (textOutput) {
+      try {
+        parsed = JSON.parse(textOutput) as Record<string, unknown>;
+      } catch {
+        return {
+          job_id: job.job_id,
+          status: "failed",
+          provider_run_id: result.id,
+          model_ref: (result as Record<string, unknown>).model as string ?? model,
+          usage: result.usage
+            ? {
+                input_tokens: result.usage.input_tokens ?? 0,
+                output_tokens: result.usage.output_tokens ?? 0,
+              }
+            : null,
+          output: null,
+          error_code: "response_parse_error",
+          error_message: "Response text is not valid JSON",
+        };
+      }
+    }
+
+    return {
+      job_id: job.job_id,
+      status: "completed",
+      provider_run_id: result.id,
+      model_ref: (result as Record<string, unknown>).model as string ?? model,
+      usage: result.usage
+        ? {
+            input_tokens: result.usage.input_tokens ?? 0,
+            output_tokens: result.usage.output_tokens ?? 0,
+          }
+        : null,
+      output: parsed,
+      error_code: null,
+      error_message: null,
+    };
+  } catch (err) {
+    if (controller.signal.aborted) {
+      return {
+        job_id: job.job_id,
+        status: "timed_out",
+        provider_run_id: null,
+        model_ref: model,
+        usage: null,
+        output: null,
+        error_code: "deadline_exceeded",
+        error_message: `Reasoning execution exceeded deadline of ${deadlineMs}ms`,
+      };
+    }
+
+    const isRetryable = err instanceof OpenResponsesError && err.retryable;
+    return {
+      job_id: job.job_id,
+      status: "failed",
+      provider_run_id: null,
+      model_ref: model,
+      usage: null,
+      output: null,
+      error_code: isRetryable ? "retryable_error" : "execution_error",
+      error_message: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/service.ts

@@ -1,13 +1,12 @@
-import type {
-  OpenClawPluginApi,
-  OpenClawPluginServiceContext,
-} from "openclaw/plugin-sdk/core";
+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";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const RECONNECT_BASE_MS = 1_000;
@@ -30,6 +29,22 @@ export function createRelayService(api: OpenClawPluginApi) {
 
   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 {
@@ -90,9 +105,7 @@ export function createRelayService(api: OpenClawPluginApi) {
     await client.updateTaskStatus(task.id, status);
   }
 
-  function extractContentFromMessage(
-    msg: Record<string, unknown>,
-  ): string | null {
+  function extractContentFromMessage(msg: Record<string, unknown>): string | null {
     const content = msg["content"];
     if (typeof content === "string") return content;
 
@@ -111,9 +124,7 @@ export function createRelayService(api: OpenClawPluginApi) {
     return null;
   }
 
-  function extractAssistantReply(
-    messages: unknown[],
-  ): string | 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;
@@ -176,14 +187,20 @@ export function createRelayService(api: OpenClawPluginApi) {
     return null;
   }
 
-  async function handleNormalTask(
-    task: TaskPayload,
-    client: StageWhisperClient,
-  ): Promise<void> {
-    try {
-      await updateStatus(client, task, "delivered");
-    } catch (err) {
-      api.logger.warn(`Failed to mark task as delivered, skipping to prevent duplicates: ${err}`);
+  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;
     }
 
@@ -199,12 +216,10 @@ export function createRelayService(api: OpenClawPluginApi) {
       sessionKey,
       message: messageContent,
       deliver: true,
-      idempotencyKey: randomUUID(),
+      idempotencyKey: `sw-task-${task.id}`,
     });
 
-    api.logger.info(
-      `Task ${task.id} dispatched to agent session (runId: ${result.runId})`,
-    );
+    api.logger.info(`Task ${task.id} dispatched to agent session (runId: ${result.runId})`);
 
     try {
       await updateStatus(client, task, "running");
@@ -225,9 +240,7 @@ export function createRelayService(api: OpenClawPluginApi) {
           }
           await updateStatus(client, task, "completed").catch(() => {});
         } else {
-          api.logger.error(
-            `Agent run failed for task ${task.id}: ${waitResult.error}`,
-          );
+          api.logger.error(`Agent run failed for task ${task.id}: ${waitResult.error}`);
           await updateStatus(client, task, "failed").catch(() => {});
         }
       })
@@ -237,10 +250,7 @@ export function createRelayService(api: OpenClawPluginApi) {
       });
   }
 
-  async function handleTestTask(
-    task: TaskPayload,
-    client: StageWhisperClient,
-  ): Promise<void> {
+  async function handleTestTask(task: TaskPayload, client: StageWhisperClient): Promise<void> {
     const messageContent = buildTaskMessage(task);
     const sessionKey = buildAgentSessionKey({
       agentId: "default",
@@ -255,9 +265,7 @@ export function createRelayService(api: OpenClawPluginApi) {
       idempotencyKey: randomUUID(),
     });
 
-    api.logger.info(
-      `Test task ${task.id} dispatched (runId: ${result.runId})`,
-    );
+    api.logger.info(`Test task ${task.id} dispatched (runId: ${result.runId})`);
 
     const waitResult = await api.runtime.subagent.waitForRun({
       runId: result.runId,
@@ -274,16 +282,11 @@ export function createRelayService(api: OpenClawPluginApi) {
         await client.testReply(task.id, "(no reply extracted)");
       }
     } else {
-      api.logger.error(
-        `Agent run failed for test task ${task.id}: ${waitResult.error}`,
-      );
+      api.logger.error(`Agent run failed for test task ${task.id}: ${waitResult.error}`);
     }
   }
 
-  async function handleTask(
-    task: TaskPayload,
-    client: StageWhisperClient,
-  ): Promise<void> {
+  async function handleTask(task: TaskPayload, client: StageWhisperClient): Promise<void> {
     api.logger.info(`Received task: ${task.title} (${task.id})`);
 
     try {
@@ -298,6 +301,76 @@ export function createRelayService(api: OpenClawPluginApi) {
     }
   }
 
+  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);
+
+    try {
+      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);
+    }
+  }
+
   async function connectStream(account: StageWhisperAccount): Promise<void> {
     const client = new StageWhisperClient(
       account.apiBaseUrl,
@@ -324,6 +397,7 @@ export function createRelayService(api: OpenClawPluginApi) {
 
     state.connected = true;
     state.reconnectAttempts = 0;
+    health.setConnected();
     api.logger.info("Connected to StageWhisper relay stream");
 
     const reader = res.body.getReader();
@@ -345,24 +419,29 @@ export function createRelayService(api: OpenClawPluginApi) {
           if (!jsonStr) continue;
 
           try {
-            const task = JSON.parse(jsonStr) as TaskPayload;
-            await handleTask(task, client);
+            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 task from stream: ${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,
-    );
+    const ms = Math.min(RECONNECT_BASE_MS * Math.pow(2, state.reconnectAttempts), RECONNECT_MAX_MS);
     return ms + Math.random() * 1000;
   }
 
@@ -372,6 +451,7 @@ export function createRelayService(api: OpenClawPluginApi) {
         await connectStream(account);
       } catch (err) {
         if (!state.running) break;
+        health.setDisconnected();
         state.reconnectAttempts++;
         const delay = backoffMs();
         api.logger.warn(
@@ -391,7 +471,7 @@ export function createRelayService(api: OpenClawPluginApi) {
 
     heartbeatTimer = setInterval(async () => {
       try {
-        await client.heartbeat();
+        await client.heartbeat(health.toHeartbeatPayload());
         state.lastHeartbeat = new Date();
       } catch (err) {
         api.logger.warn(`Heartbeat failed: ${err}`);
@@ -404,11 +484,7 @@ export function createRelayService(api: OpenClawPluginApi) {
 
     async start(_ctx: OpenClawPluginServiceContext): Promise<void> {
       const account = resolveServiceAccount();
-      if (
-        !account.apiBaseUrl ||
-        !account.integrationId ||
-        !account.relayToken
-      ) {
+      if (!account.apiBaseUrl || !account.integrationId || !account.relayToken) {
         api.logger.info(
           "StageWhisper not configured — skipping relay service. Pair first with: openclaw stagewhisper pair",
         );
@@ -420,13 +496,23 @@ export function createRelayService(api: OpenClawPluginApi) {
       );
 
       state.running = true;
+
+      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}`,
-      );
+      api.logger.info(`StageWhisper relay service started for ${account.label}`);
     },
 
     async stop(_ctx: OpenClawPluginServiceContext): Promise<void> {