@stagewhisper/stagewhisper 0.44.0 → 0.46.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.44.0",
+  "version": "0.46.0",
   "channels": [
     "stagewhisper"
   ],

package/package.json

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

package/plugin-main.ts

@@ -3,6 +3,34 @@ import { stagewhisperPlugin } from "./src/channel.js";
 import { setRuntime } from "./src/runtime.js";
 import { createRelayService } from "./src/service.js";
 
+async function ensureResponsesEndpoint(api: Parameters<Parameters<typeof definePluginEntry>[0]["register"]>[0]): Promise<void> {
+  try {
+    const cfg = await api.runtime.config.loadConfig();
+    const gw = ((cfg as Record<string, unknown>)["gateway"] ?? {}) as Record<string, unknown>;
+    const http = (gw["http"] ?? {}) as Record<string, unknown>;
+    const endpoints = (http["endpoints"] ?? {}) as Record<string, unknown>;
+    const responses = (endpoints["responses"] ?? {}) as Record<string, unknown>;
+
+    if (responses["enabled"] === true) return;
+
+    const auth = (gw["auth"] ?? {}) as Record<string, unknown>;
+    if (auth["mode"] === "none" && !auth["token"] && !auth["password"]) return;
+
+    responses["enabled"] = true;
+    endpoints["responses"] = responses;
+    http["endpoints"] = endpoints;
+    gw["http"] = http;
+    (cfg as Record<string, unknown>)["gateway"] = gw;
+
+    await api.runtime.config.writeConfigFile(cfg);
+    api.logger.info(
+      "Enabled gateway.http.endpoints.responses for StageWhisper reasoning. Restart the gateway for it to take effect.",
+    );
+  } catch {
+    // best-effort — reasoning-check will surface the real error
+  }
+}
+
 export default definePluginEntry({
   id: "stagewhisper",
   name: "StageWhisper",
@@ -10,6 +38,8 @@ export default definePluginEntry({
   register(api) {
     api.registerChannel({ plugin: stagewhisperPlugin });
 
+    ensureResponsesEndpoint(api);
+
     api.registerCli(
       ({ program }) => {
         const sw = program
@@ -27,11 +57,13 @@ export default definePluginEntry({
             "https://api.stagewhisper.io",
           )
           .option("--label <label>", "Label for this OpenClaw host", "OpenClaw")
+          .option("--no-enable-responses", "Skip enabling the gateway OpenResponses HTTP API")
           .action(
             async (opts: {
               code: string;
               apiUrl: string;
               label?: string;
+              enableResponses: boolean;
             }) => {
               const { StageWhisperClient } = await import("./src/client.js");
               const client = new StageWhisperClient(opts.apiUrl, "", "");
@@ -65,13 +97,33 @@ export default definePluginEntry({
                 };
                 (cfg as Record<string, unknown>)["channels"] = channels;
 
+                if (opts.enableResponses) {
+                  const gw = ((cfg as Record<string, unknown>)["gateway"] ?? {}) as Record<string, unknown>;
+                  const gwAuth = (gw["auth"] as Record<string, unknown>) ?? {};
+                  const authMode = gwAuth["mode"] as string | undefined;
+                  const hasToken = typeof gwAuth["token"] === "string" && (gwAuth["token"] as string).length > 0;
+
+                  if (authMode === "none" && !hasToken) {
+                    console.warn("  ⚠ gateway.auth.mode is 'none' with no token — skipping HTTP API enablement.");
+                    console.warn("    Set a gateway auth token first for reasoning to work.\n");
+                  } else {
+                    const http = (gw["http"] ?? {}) as Record<string, unknown>;
+                    const endpoints = (http["endpoints"] ?? {}) as Record<string, unknown>;
+                    const responses = (endpoints["responses"] ?? {}) as Record<string, unknown>;
+                    responses["enabled"] = true;
+                    endpoints["responses"] = responses;
+                    http["endpoints"] = endpoints;
+                    gw["http"] = http;
+                    (cfg as Record<string, unknown>)["gateway"] = gw;
+                  }
+                }
+
                 await api.runtime.config.writeConfigFile(cfg);
 
                 console.log(
                   `\n✓ Paired with StageWhisper (${result.label})`,
                 );
-                console.log("  Config saved automatically.\n");
-                console.log("  Restart the gateway to activate the relay:\n");
+                console.log("  Config saved. Restart the gateway to activate:\n");
                 console.log("  openclaw gateway restart\n");
               } catch (err) {
                 console.error(`\n✗ Pairing failed: ${err}\n`);
@@ -84,7 +136,8 @@ export default definePluginEntry({
           .description(
             "Remove StageWhisper pairing (run before `openclaw plugins uninstall`)",
           )
-          .action(async () => {
+          .option("--keep-responses", "Keep the OpenResponses HTTP API enabled after unpair")
+          .action(async (opts: { keepResponses?: boolean }) => {
             try {
               const cfg = await api.runtime.config.loadConfig();
               const plugins = (cfg as Record<string, unknown>)["plugins"] as Record<string, unknown> ?? {};
@@ -102,6 +155,20 @@ export default definePluginEntry({
                 }
               }
 
+              if (!opts.keepResponses) {
+                const gw = (cfg as Record<string, unknown>)["gateway"] as Record<string, unknown> | undefined;
+                const http = gw?.["http"] as Record<string, unknown> | undefined;
+                const endpoints = http?.["endpoints"] as Record<string, unknown> | undefined;
+                const responses = endpoints?.["responses"] as Record<string, unknown> | undefined;
+                if (responses?.["enabled"] === true) {
+                  delete responses["enabled"];
+                  if (Object.keys(responses).length === 0 && endpoints) delete endpoints["responses"];
+                  if (endpoints && Object.keys(endpoints).length === 0 && http) delete http["endpoints"];
+                  if (http && Object.keys(http).length === 0 && gw) delete gw["http"];
+                  console.log("  ℹ Disabled gateway.http.endpoints.responses. Use --keep-responses to preserve it.");
+                }
+              }
+
               await api.runtime.config.writeConfigFile(cfg);
               console.log("\n✓ StageWhisper unpaired.");
               console.log("  Config cleaned. You can now safely uninstall:\n");
@@ -116,7 +183,7 @@ export default definePluginEntry({
           .description("Test reasoning capability against the local OpenResponses endpoint")
           .option("--model <model>", "Model to use (omit to use your configured default)", "openclaw/default")
           .action(async (opts: { model: string }) => {
-            const { callOpenResponses } = await import("./src/openresponses.js");
+            const { callOpenResponses, isResponsesEndpointEnabled } = await import("./src/openresponses.js");
             const modelLabel = opts.model === "openclaw/default" ? "default (configured)" : opts.model;
 
             const cfg = api.config as Record<string, unknown>;
@@ -124,8 +191,24 @@ export default definePluginEntry({
             const auth = (gw?.auth as Record<string, unknown>) ?? {};
             const port = Number(gw?.port) || 18789;
             const hasToken = typeof auth?.token === "string" && auth.token.length > 0;
-            console.log(`Gateway: 127.0.0.1:${port}, auth token: ${hasToken ? "present" : "MISSING"}`);
-            console.log(`Testing reasoning with model: ${modelLabel}`);
+            const responsesEnabled = isResponsesEndpointEnabled(api);
+
+            console.log("Preflight checks:");
+            console.log(`  Gateway port:       ${port}`);
+            console.log(`  Auth token:         ${hasToken ? "✓ present" : "✗ MISSING"}`);
+            console.log(`  responses.enabled:  ${responsesEnabled ? "✓ true" : "✗ false"}`);
+
+            if (!responsesEnabled) {
+              console.warn("\n⚠ responses.enabled is false in the running config.");
+              console.warn("  The plugin auto-enables it on startup — restart the gateway if you haven't:");
+              console.warn("  openclaw gateway restart\n");
+            }
+
+            if (!hasToken) {
+              console.warn("\n⚠ No gateway auth token found — request may be rejected.\n");
+            }
+
+            console.log(`\nTesting reasoning with model: ${modelLabel}`);
             console.log("Sending test request to local /v1/responses ...");
 
             const start = Date.now();

package/src/openresponses.ts

@@ -11,13 +11,20 @@ function resolveGatewayConfig(api: OpenClawPluginApi): GatewayConfig {
   const explicitUrl = typeof gw?.url === "string" ? gw.url : null;
   const url = (explicitUrl ?? `http://127.0.0.1:${port}`).replace(/\/+$/, "");
 
-  const token =
-    (typeof auth?.token === "string" ? auth.token : null) ??
-    (typeof process !== "undefined" ? process.env.OPENCLAW_GATEWAY_TOKEN ?? null : null);
+  const token = typeof auth?.token === "string" ? auth.token : null;
 
   return { url, apiKey: token };
 }
 
+export function isResponsesEndpointEnabled(api: OpenClawPluginApi): boolean {
+  const cfg = api.config as Record<string, unknown>;
+  const gw = (cfg?.gateway as Record<string, unknown>) ?? {};
+  const http = (gw?.http as Record<string, unknown>) ?? {};
+  const endpoints = (http?.endpoints as Record<string, unknown>) ?? {};
+  const responses = (endpoints?.responses as Record<string, unknown>) ?? {};
+  return responses?.enabled === true;
+}
+
 export async function callOpenResponses(
   api: OpenClawPluginApi,
   requestBody: OpenResponsesCreateResponseRequestBody,
@@ -46,6 +53,13 @@ export async function callOpenResponses(
 
   if (!response.ok) {
     const body = await response.text().catch(() => "");
+    if (response.status === 404) {
+      throw new OpenResponsesError(
+        "POST /v1/responses returned 404 — the OpenResponses HTTP API is most likely disabled. " +
+        'Enable it in OpenClaw config: gateway.http.endpoints.responses.enabled = true, then restart the gateway.',
+        response.status,
+      );
+    }
     throw new OpenResponsesError(`POST /v1/responses returned ${response.status}: ${body}`, response.status);
   }
   return (await response.json()) as OpenResponsesResponseResource;

package/src/service.ts

@@ -7,6 +7,7 @@ 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";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const RECONNECT_BASE_MS = 1_000;
@@ -497,6 +498,13 @@ export function createRelayService(api: OpenClawPluginApi) {
 
       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) {