@stagewhisper/stagewhisper 0.53.0 → 0.55.0

package/dist/index.js

@@ -128,6 +128,17 @@ var init_client = __esm({
           throw new Error(`Reasoning result post failed (${res.status}): ${text}`);
         }
       }
+      async getReasoningJob(jobId) {
+        const res = await fetch(`${this.baseUrl}/api/v1/openclaw/reasoning-jobs/${jobId}`, {
+          method: "GET",
+          headers: this.headers()
+        });
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(`Reasoning job fetch failed (${res.status}): ${text}`);
+        }
+        return res.json();
+      }
       streamUrl() {
         return `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/stream`;
       }
@@ -4236,6 +4247,40 @@ function createRelayService(api) {
     }
     return null;
   }
+  function waitTimeoutMsForJob(job, fallbackMs) {
+    const parsedDeadline = new Date(job.deadline_at).getTime();
+    if (!Number.isFinite(parsedDeadline)) return fallbackMs;
+    return Math.max(1e3, parsedDeadline - Date.now());
+  }
+  function needsReasoningJobHydration(job) {
+    if (job["_truncated"] === true) return true;
+    if (typeof job["deadline_at"] !== "string") return true;
+    if (typeof job["idempotency_key"] !== "string") return true;
+    const responseSchema = job["response_schema"];
+    if (typeof responseSchema !== "object" || responseSchema === null) return true;
+    const payload = job["payload"];
+    if (typeof payload !== "object" || payload === null) return true;
+    return payload["_truncated"] === true;
+  }
+  async function hydrateReasoningJobEnvelope(rawJob, client) {
+    const payload = rawJob["payload"];
+    const payloadRecord = typeof payload === "object" && payload !== null ? payload : null;
+    const jobId = typeof rawJob["job_id"] === "string" ? rawJob["job_id"] : typeof payloadRecord?.["job_id"] === "string" ? payloadRecord["job_id"] : typeof payloadRecord?.["id"] === "string" ? payloadRecord["id"] : null;
+    if (!jobId) {
+      api.logger.error("Received reasoning job without job_id");
+      return null;
+    }
+    if (!needsReasoningJobHydration(rawJob)) {
+      return rawJob;
+    }
+    try {
+      api.logger.info(`Hydrating truncated reasoning job ${jobId}`);
+      return await client.getReasoningJob(jobId);
+    } catch (err) {
+      api.logger.error(`Failed to hydrate reasoning job ${jobId}: ${err}`);
+      return null;
+    }
+  }
   async function extractReplyForTask(sessionKey, taskId, maxAttempts = 3) {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       if (attempt > 0) {
@@ -4451,7 +4496,7 @@ function createRelayService(api) {
       });
       const waitResult = await api.runtime.subagent.waitForRun({
         runId: result.runId,
-        timeoutMs: 35e3
+        timeoutMs: waitTimeoutMsForJob(job, 6e4)
       });
       if (waitResult.status === "ok") {
         const reply = await extractReplyWithRetry(sessionKey);
@@ -4645,7 +4690,7 @@ function createRelayService(api) {
     } else {
       health.recordFailure(result.error_message ?? `reasoning ${result.status}`);
     }
-    let encryptedResult;
+    let completionResult;
     try {
       const resultJson = JSON.stringify(result.output ?? {});
       const resultBytes = new TextEncoder().encode(resultJson);
@@ -4659,28 +4704,40 @@ function createRelayService(api) {
         "reasoning_output",
         resultBytes
       );
-      encryptedResult = {
-        byo_encrypted: true,
-        envelope: resultEnvelope,
-        job_id: job.job_id,
+      completionResult = {
         status: result.status,
+        provider_run_id: result.provider_run_id,
+        model_ref: result.model_ref,
         usage: result.usage,
-        model_ref: result.model_ref
+        output: {
+          byo_encrypted: true,
+          envelope: resultEnvelope,
+          status: result.status
+        },
+        error_code: result.error_code,
+        error_message: result.error_message
       };
     } catch (err) {
       api.logger.error(`BYO job ${job.job_id} result encryption failed: ${err}`);
-      encryptedResult = {
-        job_id: job.job_id,
+      completionResult = {
         status: "failed",
+        provider_run_id: result.provider_run_id,
+        model_ref: result.model_ref,
+        usage: result.usage,
+        output: {
+          byo_encrypted: true,
+          status: "failed",
+          error_code: "encryption_error",
+          error_message: "Failed to encrypt result"
+        },
         error_code: "encryption_error",
-        error_message: "Failed to encrypt result",
-        byo_encrypted: true
+        error_message: "Failed to encrypt result"
       };
     }
     try {
       await client.postReasoningResult(
         job.job_id,
-        encryptedResult,
+        completionResult,
         correlationId
       );
       completedReasoningJobs.set(job.job_id, Date.now());
@@ -4690,6 +4747,14 @@ function createRelayService(api) {
     }
   }
   async function handleReasoningJob(job, client) {
+    const hydrated = await hydrateReasoningJobEnvelope(
+      job,
+      client
+    );
+    if (!hydrated) {
+      return;
+    }
+    job = hydrated;
     const correlationId = job.correlation_id;
     api.logger.info(
       `Received reasoning job: ${job.job_id} (purpose: ${job.purpose}, correlation: ${correlationId ?? "none"})`

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "stagewhisper",
   "name": "StageWhisper",
   "description": "Turn live call moments into assistant tasks via StageWhisper",
-  "version": "0.53.0",
+  "version": "0.55.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

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