fix(openclaw): fallback to wake compatibility for /hooks/wake in sse mode

packages/adapters/openclaw/src/server/execute.ts

@@ -456,7 +456,56 @@ export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExec
   const timeout = setTimeout(() => controller.abort(), timeoutSec * 1000);
 
   try {
+    const preferWakeTextPayload = shouldUseWakeTextPayload(url);
+
     if (transport === "sse") {
+      if (preferWakeTextPayload) {
+        await onLog(
+          "stdout",
+          "[openclaw] /hooks/wake compatibility endpoint does not stream SSE; falling back to wake text payload\n",
+        );
+        const retry = await sendWebhookRequest({
+          url,
+          method,
+          headers,
+          payload: wakeTextBody,
+          onLog,
+          signal: controller.signal,
+        });
+
+        if (retry.response.ok) {
+          return {
+            exitCode: 0,
+            signal: null,
+            timedOut: false,
+            provider: "openclaw",
+            model: null,
+            summary: `OpenClaw webhook ${method} ${url} (wake compatibility fallback)`,
+            resultJson: {
+              status: retry.response.status,
+              statusText: retry.response.statusText,
+              compatibilityMode: "wake_text",
+              transportFallback: "webhook",
+              response: parseOpenClawResponse(retry.responseText) ?? retry.responseText,
+            },
+          };
+        }
+        return {
+          exitCode: 1,
+          signal: null,
+          timedOut: false,
+          errorMessage: `OpenClaw webhook failed with status ${retry.response.status}`,
+          errorCode: "openclaw_http_error",
+          resultJson: {
+            status: retry.response.status,
+            statusText: retry.response.statusText,
+            compatibilityMode: "wake_text",
+            transportFallback: "webhook",
+            response: parseOpenClawResponse(retry.responseText) ?? retry.responseText,
+          },
+        };
+      }
+
       const sseHeaders = {
         ...headers,
         accept: "text/event-stream",
@@ -472,6 +521,37 @@ export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExec
 
       if (!response.ok) {
         const responseText = await readAndLogResponseText({ response, onLog });
+        if (isTextRequiredResponse(responseText)) {
+          await onLog(
+            "stdout",
+            "[openclaw] SSE endpoint reported text-required; falling back to wake compatibility payload\n",
+          );
+          const retry = await sendWebhookRequest({
+            url,
+            method,
+            headers,
+            payload: wakeTextBody,
+            onLog,
+            signal: controller.signal,
+          });
+          if (retry.response.ok) {
+            return {
+              exitCode: 0,
+              signal: null,
+              timedOut: false,
+              provider: "openclaw",
+              model: null,
+              summary: `OpenClaw webhook ${method} ${url} (wake compatibility fallback)`,
+              resultJson: {
+                status: retry.response.status,
+                statusText: retry.response.statusText,
+                compatibilityMode: "wake_text",
+                transportFallback: "webhook",
+                response: parseOpenClawResponse(retry.responseText) ?? retry.responseText,
+              },
+            };
+          }
+        }
         return {
           exitCode: 1,
           signal: null,
@@ -489,6 +569,37 @@ export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExec
       const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
       if (!contentType.includes("text/event-stream")) {
         const responseText = await readAndLogResponseText({ response, onLog });
+        if (isTextRequiredResponse(responseText)) {
+          await onLog(
+            "stdout",
+            "[openclaw] non-SSE response indicated text-required; falling back to wake compatibility payload\n",
+          );
+          const retry = await sendWebhookRequest({
+            url,
+            method,
+            headers,
+            payload: wakeTextBody,
+            onLog,
+            signal: controller.signal,
+          });
+          if (retry.response.ok) {
+            return {
+              exitCode: 0,
+              signal: null,
+              timedOut: false,
+              provider: "openclaw",
+              model: null,
+              summary: `OpenClaw webhook ${method} ${url} (wake compatibility fallback)`,
+              resultJson: {
+                status: retry.response.status,
+                statusText: retry.response.statusText,
+                compatibilityMode: "wake_text",
+                transportFallback: "webhook",
+                response: parseOpenClawResponse(retry.responseText) ?? retry.responseText,
+              },
+            };
+          }
+        }
         return {
           exitCode: 1,
           signal: null,
@@ -539,7 +650,6 @@ export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExec
       };
     }
 
-    const preferWakeTextPayload = shouldUseWakeTextPayload(url);
     if (preferWakeTextPayload) {
       await onLog("stdout", "[openclaw] using wake text payload for /hooks/wake compatibility\n");
     }

server/src/__tests__/openclaw-adapter.test.ts

@@ -140,6 +140,28 @@ describe("openclaw adapter execute", () => {
     expect(result.errorCode).toBe("openclaw_sse_expected_event_stream");
   });
 
+  it("falls back to wake text payload when SSE is configured against /hooks/wake", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ ok: true }), { status: 200, statusText: "OK" }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await execute(
+      buildContext({
+        url: "https://agent.example/hooks/wake",
+        method: "POST",
+      }),
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body ?? "{}")) as Record<string, unknown>;
+    expect(body.mode).toBe("now");
+    expect(typeof body.text).toBe("string");
+    expect(result.resultJson?.compatibilityMode).toBe("wake_text");
+    expect(result.resultJson?.transportFallback).toBe("webhook");
+  });
+
   it("uses wake text payload for /hooks/wake endpoints in webhook mode", async () => {
     const fetchMock = vi.fn().mockResolvedValue(
       new Response(JSON.stringify({ ok: true }), { status: 200, statusText: "OK" }),