@stagewhisper/stagewhisper 0.46.0 → 0.49.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.46.0",
+  "version": "0.49.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

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

package/plugin-main.ts

@@ -38,8 +38,6 @@ export default definePluginEntry({
   register(api) {
     api.registerChannel({ plugin: stagewhisperPlugin });
 
-    ensureResponsesEndpoint(api);
-
     api.registerCli(
       ({ program }) => {
         const sw = program
@@ -211,6 +209,27 @@ export default definePluginEntry({
             console.log(`\nTesting reasoning with model: ${modelLabel}`);
             console.log("Sending test request to local /v1/responses ...");
 
+            const testSchema = {
+              type: "object",
+              properties: {
+                signals: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      severity: { type: "string", enum: ["green", "orange", "red"] },
+                      message: { type: "string" },
+                    },
+                    required: ["severity", "message"],
+                    additionalProperties: false,
+                  },
+                },
+                no_signal_reason: { type: "string" },
+              },
+              required: ["signals", "no_signal_reason"],
+              additionalProperties: false,
+            };
+
             const start = Date.now();
             try {
               const result = await callOpenResponses(api, {
@@ -219,34 +238,14 @@ export default definePluginEntry({
                   transcript: "Candidate: I think we should use Redis for caching.",
                   playbook_guidance: "Evaluate technical decisions",
                 }),
-                text: {
-                  format: {
-                    type: "json_schema" as const,
-                    name: "reasoning_test",
-                    schema: {
-                      type: "object",
-                      properties: {
-                        signals: {
-                          type: "array",
-                          items: {
-                            type: "object",
-                            properties: {
-                              severity: { type: "string", enum: ["green", "orange", "red"] },
-                              message: { type: "string" },
-                            },
-                            required: ["severity", "message"],
-                            additionalProperties: false,
-                          },
-                        },
-                        no_signal_reason: { type: "string" },
-                      },
-                      required: ["signals", "no_signal_reason"],
-                      additionalProperties: false,
-                    },
-                    strict: true,
-                  },
-                },
-                temperature: 0.2,
+                instructions: [
+                  'You are a structured reasoning engine for the "reasoning_test" task.',
+                  "You MUST respond with a JSON object conforming to this schema.",
+                  "Output ONLY valid JSON. No markdown fences, no explanation, no extra text.",
+                  "",
+                  "JSON Schema:",
+                  JSON.stringify(testSchema, null, 2),
+                ].join("\n"),
                 max_output_tokens: 1024,
               });
 
@@ -260,17 +259,18 @@ export default definePluginEntry({
               }
 
               const output = result.output;
-              const text = Array.isArray(output)
+              const msgItem = Array.isArray(output)
                 ? (output.find((o) => o.type === "message") as Record<string, unknown> | undefined)
                 : null;
-              const textContent = text
-                ? ((text.content as Array<Record<string, unknown>>)?.find(
+              const textContent = msgItem
+                ? ((msgItem.content as Array<Record<string, unknown>>)?.find(
                     (c) => c.type === "output_text",
                   )?.text as string | undefined)
                 : null;
               if (textContent) {
+                const cleaned = textContent.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/, "").trim();
                 try {
-                  const parsed = JSON.parse(textContent);
+                  const parsed = JSON.parse(cleaned);
                   console.log("  Schema-valid JSON: ✓");
                   console.log(`  Output: ${JSON.stringify(parsed, null, 2)}`);
                 } catch {
@@ -334,6 +334,7 @@ export default definePluginEntry({
 
     if (api.registrationMode !== "full") return;
 
+    ensureResponsesEndpoint(api);
     setRuntime(api.runtime);
     const service = createRelayService(api);
     api.registerService(service);

package/src/reasoning.ts

@@ -19,7 +19,6 @@ export async function probeOpenResponses(
     model: "openclaw/default",
     input: "Reply with exactly: OK",
     max_output_tokens: 16,
-    temperature: 0,
   };
 
   const controller = new AbortController();
@@ -81,6 +80,23 @@ function extractTextOutput(result: OpenResponsesResponseResource): string | null
   return null;
 }
 
+function buildSchemaInstruction(schema: Record<string, unknown>, purpose: string, systemInstruction?: string): string {
+  const parts: string[] = [];
+  if (systemInstruction) {
+    parts.push(systemInstruction);
+    parts.push("");
+  }
+  parts.push(
+    `You are a structured reasoning engine for the "${purpose}" task.`,
+    "You MUST respond with a JSON object conforming to this schema.",
+    "Output ONLY valid JSON. No markdown fences, no explanation, no extra text.",
+    "",
+    "JSON Schema:",
+    JSON.stringify(schema, null, 2),
+  );
+  return parts.join("\n");
+}
+
 export async function executeReasoningJob(
   api: OpenClawPluginApi,
   job: ReasoningJobEnvelope,
@@ -109,17 +125,12 @@ export async function executeReasoningJob(
   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,
-      },
-    },
+    instructions: buildSchemaInstruction(
+      job.response_schema,
+      job.purpose,
+      (job.payload.system_instruction as string) ?? undefined,
+    ),
     max_output_tokens: 4096,
-    temperature: 0.2,
   };
 
   const controller = new AbortController();
@@ -131,8 +142,9 @@ export async function executeReasoningJob(
 
     let parsed: Record<string, unknown> | null = null;
     if (textOutput) {
+      const cleaned = textOutput.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/, "").trim();
       try {
-        parsed = JSON.parse(textOutput) as Record<string, unknown>;
+        parsed = JSON.parse(cleaned) as Record<string, unknown>;
       } catch {
         return {
           job_id: job.job_id,

package/src/service.ts

@@ -302,12 +302,101 @@ export function createRelayService(api: OpenClawPluginApi) {
     }
   }
 
+  async function handleCapabilityProbe(
+    job: ReasoningJobEnvelope,
+    client: StageWhisperClient,
+  ): Promise<void> {
+    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}` },
+    });
+
+    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,
+        );
+        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,
+        );
+      }
+    } 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,
+        );
+      } catch (postErr) {
+        api.logger.error(`Failed to report probe failure: ${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"})`);
+    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}`);
@@ -319,6 +408,16 @@ export function createRelayService(api: OpenClawPluginApi) {
     }
     processingReasoningJobs.add(job.job_id);
 
+    if (job.purpose === "capability_probe") {
+      try {
+        await handleCapabilityProbe(job, client);
+        completedReasoningJobs.set(job.job_id, Date.now());
+      } finally {
+        processingReasoningJobs.delete(job.job_id);
+      }
+      return;
+    }
+
     try {
       const displayModel = health.get().displayModel ?? null;
 
@@ -331,16 +430,20 @@ export function createRelayService(api: OpenClawPluginApi) {
         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);
+          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}`);
         }
@@ -358,7 +461,11 @@ export function createRelayService(api: OpenClawPluginApi) {
       }
 
       try {
-        await client.postReasoningResult(job.job_id, result as unknown as Record<string, unknown>, correlationId);
+        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();
@@ -401,6 +508,18 @@ export function createRelayService(api: OpenClawPluginApi) {
     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 = "";
@@ -501,7 +620,7 @@ export function createRelayService(api: OpenClawPluginApi) {
       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",
+            "Enable it in config and restart the gateway, or re-pair with: openclaw stagewhisper pair --code <CODE> --enable-responses",
         );
       }