@mininglamp-oss/octo-runtime 1.1.1 → 1.1.3

package/node_modules/@mininglamp-oss/octo-runtime-adapter-openclaw/dist/index.js

@@ -3,6 +3,7 @@ import { canonicalTerminalStatus } from "@mininglamp-oss/octo-runtime-protocol";
 import { randomUUID } from "node:crypto";
 import { OpenClawGatewayClient } from "./gateway.js";
 import { resolveOpenClawGateway, localGatewayFailure } from "./local-gateway.js";
+import { resolveGatewayContract, resolveGatewayPermission, gatewayCreateParams, gatewayLegacyPermissionParams, gatewayTerminal, isGatewayRunPending } from "./compatibility.js";
 export const OPENCLAW_PROVIDER_OPTIONS = {
     url: "OPENCLAW_GATEWAY_URL",
     token: "OPENCLAW_GATEWAY_TOKEN",
@@ -60,10 +61,7 @@ export function buildOpenClawGatewayInvocation(req) {
     const createParams = {
         key: sessionKey,
         agentId,
-        permissionMode: req.approvalMode === "full_access" ? "full" : "guarded",
-        idempotencyKey: `${requestId}-session`,
-        ...(model ? { model } : {}),
-        ...(thinking ? { thinkingLevel: thinking } : {})
+        ...(model ? { model } : {})
     };
     const agentParams = {
         message,
@@ -156,7 +154,7 @@ function normalizeGatewayAgentEvent(payload, state) {
         return [];
     state.lastSeq = seq;
     const events = [];
-    const stepId = `openclaw:${nonEmptyString(native.runId) ?? "run"}`;
+    const stepId = (state.stepId ??= `openclaw:${nonEmptyString(native.runId) ?? "run"}`);
     const ensureStep = () => {
         if (state.stepStarted)
             return;
@@ -165,9 +163,13 @@ function normalizeGatewayAgentEvent(payload, state) {
     };
     if (stream === "lifecycle") {
         const phase = nonEmptyString(data.phase);
+        const terminal = gatewayTerminal(data, "lifecycle");
         if (phase === "start")
             ensureStep();
-        if ((phase === "end" || phase === "error") && state.stepStarted && !state.stepFinished) {
+        if ((phase === "end" || phase === "error") &&
+            terminal &&
+            state.stepStarted &&
+            !state.stepFinished) {
             state.stepFinished = true;
             const finishReason = nonEmptyString(data.stopReason);
             events.push({
@@ -175,7 +177,7 @@ function normalizeGatewayAgentEvent(payload, state) {
                 type: "model_step.finished",
                 payload: {
                     stepId,
-                    status: canonicalTerminalStatus(phase === "error" ? "failed" : data.aborted === true ? "cancelled" : "completed"),
+                    status: canonicalTerminalStatus(terminal),
                     ...(finishReason ? { finishReason } : {})
                 }
             });
@@ -319,12 +321,9 @@ function terminalState(payload) {
     if (native?.stream !== "lifecycle")
         return undefined;
     const data = asRecord(native.data);
-    const phase = nonEmptyString(data?.phase);
-    if (phase === "error")
-        return data?.aborted === true ? "cancelled" : "failed";
-    if (phase === "end")
-        return data?.aborted === true ? "cancelled" : "completed";
-    return undefined;
+    if (data?.phase !== "end" && data?.phase !== "error")
+        return undefined;
+    return gatewayTerminal(data, "lifecycle");
 }
 function terminalError(payload) {
     return (nonEmptyString(asRecord(asRecord(payload)?.data)?.error) ?? "OpenClaw Gateway agent run failed");
@@ -334,19 +333,10 @@ async function waitForConfirmedTerminal(client, runId, expected, deadlineAt) {
         const waitMs = Math.max(1, Math.min(30_000, deadlineAt - Date.now()));
         const result = asRecord(await client.request("agent.wait", { runId, timeoutMs: waitMs }, { timeoutMs: waitMs + 2_000 }));
         const status = nonEmptyString(result?.status);
-        const stopReason = nonEmptyString(result?.stopReason);
-        const endedAt = finiteNumber(result?.endedAt);
-        const cancelled = endedAt !== undefined && (stopReason === "aborted" || stopReason === "restart");
-        const actual = cancelled
-            ? "cancelled"
-            : status === "ok"
-                ? "completed"
-                : status === "error" || (status === "timeout" && endedAt !== undefined)
-                    ? "failed"
-                    : undefined;
-        if (actual === expected)
-            return;
-        if (!actual && (status === "pending" || status === "timeout")) {
+        const actual = gatewayTerminal(result, "wait");
+        if (actual && (expected === undefined || actual === expected))
+            return actual;
+        if (!actual && (isGatewayRunPending(result) || status === "timeout")) {
             await new Promise((resolve) => setTimeout(resolve, Math.min(250, Math.max(0, deadlineAt - Date.now()))));
             continue;
         }
@@ -355,14 +345,15 @@ async function waitForConfirmedTerminal(client, runId, expected, deadlineAt) {
             ? `OpenClaw Gateway confirmed ${actual ?? status ?? "unknown"}, not ${expected}: ${error}`
             : `OpenClaw Gateway confirmed ${actual ?? status ?? "unknown"}, not ${expected}`);
     }
-    throw new Error(`OpenClaw Gateway did not confirm ${expected} before the invocation deadline`);
+    throw new Error(`OpenClaw Gateway did not confirm ${expected ?? "a terminal state"} before the invocation deadline`);
 }
-function normalizeFinalResponse(value, state) {
+function normalizeFinalResponse(value, state, runId) {
     const response = asRecord(value);
     const result = asRecord(response?.result);
     const meta = asRecord(result?.meta);
     const agentMeta = asRecord(meta?.agentMeta);
     const events = [];
+    const stepId = (state.stepId ??= `openclaw:${runId}`);
     const payloads = Array.isArray(result?.payloads) ? result.payloads : [];
     const finalText = payloads
         .map((item) => nonEmptyString(asRecord(item)?.text) ?? "")
@@ -375,7 +366,7 @@ function normalizeFinalResponse(value, state) {
         events.push({
             protocolVersion: 2,
             type: "model_step.started",
-            payload: { stepId: `openclaw:${nonEmptyString(response?.runId) ?? "run"}` }
+            payload: { stepId }
         });
     };
     if (finalText) {
@@ -412,14 +403,7 @@ function normalizeFinalResponse(value, state) {
     });
     if (usageUpdate)
         events.push(usageUpdate);
-    const status = nonEmptyString(response?.status);
-    const terminal = status === "ok"
-        ? meta?.aborted === true
-            ? "cancelled"
-            : "completed"
-        : status
-            ? "failed"
-            : undefined;
+    const terminal = gatewayTerminal(response, "final");
     if (terminal && !state.stepFinished) {
         ensureStep();
         state.stepFinished = true;
@@ -427,7 +411,7 @@ function normalizeFinalResponse(value, state) {
             protocolVersion: 2,
             type: "model_step.finished",
             payload: {
-                stepId: `openclaw:${nonEmptyString(response?.runId) ?? "run"}`,
+                stepId,
                 status: canonicalTerminalStatus(terminal === "cancelled" ? "cancelled" : terminal === "failed" ? "failed" : "completed"),
                 ...(nonEmptyString(meta?.stopReason)
                     ? { finishReason: nonEmptyString(meta?.stopReason) }
@@ -443,32 +427,10 @@ function normalizeFinalResponse(value, state) {
             : {})
     };
 }
-function assertRuntimeGatewayContract(value) {
-    const hello = asRecord(value);
-    const features = asRecord(hello?.features);
-    const methods = Array.isArray(features?.methods) ? features.methods : [];
-    const events = Array.isArray(features?.events) ? features.events : [];
-    if (hello?.protocol !== 4)
-        throw new Error(`unsupported OpenClaw Gateway protocol: ${String(hello?.protocol)}`);
-    const requiredMethods = [
-        "sessions.create",
-        "sessions.messages.subscribe",
-        "agent",
-        "agent.wait",
-        "sessions.abort"
-    ];
-    requiredMethods.unshift("agents.list");
-    for (const method of requiredMethods) {
-        if (!methods.includes(method))
-            throw new Error(`OpenClaw Gateway does not advertise required method ${method}`);
-    }
-    if (!events.includes("agent"))
-        throw new Error("OpenClaw Gateway does not advertise the agent event stream");
-}
 async function* invokeOpenClawGateway(req, invocation, context, clientFactory, permissions) {
     const client = clientFactory(invocation.gateway);
     const requestAbort = new AbortController();
-    let resourceFailure = false;
+    let resourceFailure;
     let terminal;
     let closing;
     const stop = (cancel = false) => {
@@ -477,7 +439,7 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
         unsubscribe();
         requestAbort.abort();
         closing = (async () => {
-            if (cancel && agentAccepted)
+            if (cancel && agentDispatched)
                 await client
                     .request("sessions.abort", {
                     key: providerSessionKey,
@@ -491,25 +453,74 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
         void closing.catch(() => undefined);
         return closing;
     };
-    permissions.bindTransport(() => stop(!terminal));
+    let cancellation;
+    const confirmCancellation = () => {
+        cancellation ??= (async () => {
+            if (!agentDispatched)
+                return;
+            let recoveryClient;
+            try {
+                const abortParams = {
+                    key: providerSessionKey,
+                    runId: acceptedRunId,
+                    agentId: invocation.agentId
+                };
+                let controlClient = client;
+                try {
+                    await controlClient.request("sessions.abort", abortParams, { timeoutMs: 5_000 });
+                }
+                catch {
+                    recoveryClient = clientFactory(invocation.gateway);
+                    resolveGatewayContract(await recoveryClient.connect());
+                    controlClient = recoveryClient;
+                    await controlClient.request("sessions.abort", abortParams, { timeoutMs: 5_000 });
+                }
+                await waitForConfirmedTerminal(controlClient, acceptedRunId, "cancelled", Date.now() + 30_000);
+                terminal ??= "cancelled";
+            }
+            finally {
+                await recoveryClient?.close();
+            }
+        })();
+        return cancellation;
+    };
+    // 桥和执行循环可能同时收到取消；共用一次 abort/对账，确认后才关闭连接。
+    permissions.bindTransport(async () => {
+        if (req.signal?.aborted && !terminal) {
+            try {
+                await confirmCancellation();
+            }
+            catch {
+                // 执行源负责发出取消对账失败；清理桥不重复抛出同一错误。
+            }
+            finally {
+                await stop(false);
+            }
+        }
+        else
+            await stop(!terminal);
+    });
     const queue = new DriverQueue({
         discardOnFailure: true,
         limits: context?.streamLimits,
         boundary: "openclaw.event_queue",
-        onFailure: () => {
-            resourceFailure = true;
+        onFailure: (error) => {
+            if (req.signal?.aborted)
+                return;
+            resourceFailure = error;
             void stop(true);
         }
     });
     const iterator = queue[Symbol.asyncIterator]();
     let acceptedRunId = invocation.requestId;
+    let agentDispatched = false;
     let agentAccepted = false;
     const seenApprovals = new Set();
     const activeApprovals = new Map();
     let providerSessionKey = invocation.sessionKey;
     const routedApprovals = new Set();
     const acceptEvent = (event) => {
-        if (closing)
+        if (closing || terminal)
             return;
         const payload = asRecord(event.payload);
         if (event.event === "agent") {
@@ -555,32 +566,98 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
         messages: new Map(),
         tools: new Set()
     };
+    // 原生终态和步骤收尾共用出口；旧等待失败不能覆盖已确认的结果或丢失步骤结束。
+    const terminalEvents = (outcome, message) => {
+        const events = [];
+        if (state.stepStarted && !state.stepFinished) {
+            state.stepFinished = true;
+            events.push({
+                protocolVersion: 2,
+                type: "model_step.finished",
+                payload: { stepId: state.stepId, status: canonicalTerminalStatus(outcome) }
+            });
+        }
+        events.push({
+            protocolVersion: 2,
+            type: "message.update",
+            payload: {
+                ...gatewayMessage(state, "final", state.assistantItemId),
+                role: "assistant",
+                status: outcome === "cancelled" ? "stopped" : outcome,
+                text: state.assistantText,
+                channel: "final"
+            }
+        });
+        if (outcome === "cancelled")
+            events.push({
+                protocolVersion: 2,
+                type: "run.cancelled",
+                payload: { reason: String(req.signal?.reason ?? "openclaw_aborted") }
+            });
+        else if (outcome === "completed")
+            events.push({ protocolVersion: 2, type: "run.completed", payload: {} });
+        else
+            events.push({
+                protocolVersion: 2,
+                type: "run.failed",
+                payload: {
+                    message: message ?? "OpenClaw Gateway agent run failed",
+                    adapterType: "openclaw"
+                }
+            });
+        return events;
+    };
     try {
         const hello = await client.connect();
-        assertRuntimeGatewayContract(hello);
-        if (req.approvalMode === "ask") {
-            const features = asRecord(asRecord(hello)?.features);
-            if (!Array.isArray(features?.methods) ||
-                !features.methods.includes("exec.approval.resolve") ||
-                !features.methods.includes("exec.approval.list") ||
-                !Array.isArray(features.events) ||
-                !features.events.includes("exec.approval.requested") ||
-                !features.events.includes("exec.approval.resolved")) {
-                throw new Error("APPROVAL_MODE_UNSUPPORTED: OpenClaw Gateway has no approval transport");
-            }
-        }
+        const contract = resolveGatewayContract(hello);
+        const policy = resolveGatewayPermission(contract, req.approvalMode);
+        permissions.options.effectiveApprovalMode = policy.effective;
+        // 参数在真实握手之后生成；probe 的版本快照不作为本次执行依据。
+        const createParams = gatewayCreateParams(contract, policy, invocation.createParams, invocation.requestId, invocation.agentParams.thinking);
+        if (policy.fallbackReason)
+            yield {
+                protocolVersion: 2,
+                type: "run.notice",
+                payload: {
+                    noticeId: `${req.invocationId}:openclaw-permission`,
+                    code: "provider_diagnostic",
+                    severity: "warning",
+                    params: {
+                        adapter: "openclaw",
+                        diagnosticId: `openclaw-compat-${randomUUID()}`,
+                        category: "permission_fallback",
+                        message: `OpenClaw ${contract.version}: requested ask; using full_access for this invocation (${policy.fallbackReason}).`
+                    }
+                }
+            };
         await assertExistingAgent(client, invocation.agentId, req.signal);
-        const created = asRecord(await client.request("sessions.create", invocation.createParams, {
+        const created = asRecord(await client.request("sessions.create", createParams, {
             timeoutMs: 30_000,
             signal: req.signal
         }));
-        providerSessionKey = nonEmptyString(created?.key) ?? invocation.sessionKey;
+        const createdKey = nonEmptyString(created?.key);
+        if (!createdKey)
+            throw new Error("OpenClaw Gateway returned no created session key");
+        providerSessionKey = createdKey;
         invocation.agentParams.sessionKey = providerSessionKey;
+        if (contract.family === "legacy") {
+            const patched = asRecord(await client.request("sessions.patch", gatewayLegacyPermissionParams(providerSessionKey), {
+                timeoutMs: 10_000,
+                signal: req.signal
+            }));
+            const entry = asRecord(patched?.entry);
+            if (patched?.ok !== true ||
+                patched.key !== providerSessionKey ||
+                entry?.execSecurity !== "full" ||
+                entry.execAsk !== "off") {
+                throw new Error("OPENCLAW_PERMISSION_UNAVAILABLE: legacy session policy was not confirmed");
+            }
+        }
         await client.request("sessions.messages.subscribe", {
             key: providerSessionKey,
             agentId: invocation.agentId
         }, { timeoutMs: 10_000, signal: req.signal });
-        if (req.approvalMode === "ask") {
+        if (policy.effective === "ask") {
             const pending = await client.request("exec.approval.list", {}, { timeoutMs: 10_000, signal: req.signal });
             if (!Array.isArray(pending))
                 throw new Error("OpenClaw Gateway returned invalid pending approvals");
@@ -598,6 +675,9 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
                 }
             }
         };
+        if (req.signal?.aborted)
+            throw new Error("OpenClaw invocation aborted before dispatch");
+        agentDispatched = true;
         const request = client.request("agent", invocation.agentParams, {
             expectFinal: true,
             timeoutMs: null,
@@ -612,18 +692,46 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
         void request.then((result) => queue.push({ done: true, result }), (error) => queue.push({ error: error instanceof Error ? error : new Error(String(error)) }));
         while (!terminal) {
             const next = await iterator.next();
+            if (terminal)
+                break;
             if (next.done)
                 throw new Error("OpenClaw event queue closed before terminal");
             const item = next.value;
             if (item.error)
                 throw item.error;
             if (item.done) {
-                const reconciled = normalizeFinalResponse(item.result, state);
+                const reconciled = normalizeFinalResponse(item.result, state, acceptedRunId);
+                terminal = reconciled.terminal;
+                // 先保存原生终态，避免消费者在接收收尾事件时取消而覆盖真实结果。
                 for (const event of reconciled.events)
                     yield event;
-                terminal = reconciled.terminal;
+                if (!terminal) {
+                    const confirmed = await waitForConfirmedTerminal(client, acceptedRunId, undefined, invocation.reconciliationDeadlineAt);
+                    if (resourceFailure)
+                        throw resourceFailure;
+                    terminal ??= confirmed;
+                    if (!state.stepFinished) {
+                        if (!state.stepStarted) {
+                            state.stepStarted = true;
+                            yield {
+                                protocolVersion: 2,
+                                type: "model_step.started",
+                                payload: { stepId: state.stepId }
+                            };
+                        }
+                        state.stepFinished = true;
+                        yield {
+                            protocolVersion: 2,
+                            type: "model_step.finished",
+                            payload: {
+                                stepId: state.stepId,
+                                status: canonicalTerminalStatus(terminal)
+                            }
+                        };
+                    }
+                }
                 if (terminal === "failed")
-                    throw new Error(reconciled.error);
+                    throw new Error(reconciled.error ?? "OpenClaw Gateway agent run failed");
                 break;
             }
             if (item.event?.event === "exec.approval.resolved") {
@@ -718,151 +826,58 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
             const runId = nonEmptyString(native?.runId);
             if (!runId || (runId !== acceptedRunId && runId !== invocation.requestId))
                 continue;
+            const nativeTerminal = terminalState(item.event.payload);
+            if (nativeTerminal) {
+                const confirmed = await waitForConfirmedTerminal(client, runId, nativeTerminal, invocation.reconciliationDeadlineAt);
+                if (resourceFailure)
+                    throw resourceFailure;
+                // await 期间取消任务可能先完成；较早发出的等待不能覆盖较新的确认。
+                terminal ??= confirmed;
+                if (terminal !== nativeTerminal)
+                    break;
+            }
             const events = normalizeGatewayAgentEvent(item.event.payload, state);
             for (const event of events)
                 yield event;
-            terminal = terminalState(item.event.payload);
-            if (terminal) {
-                await waitForConfirmedTerminal(client, runId, terminal, invocation.reconciliationDeadlineAt);
-                if (terminal === "failed")
-                    throw new Error(terminalError(item.event.payload));
-            }
+            if (terminal === "failed")
+                throw new Error(terminalError(item.event.payload));
         }
-        if (req.signal?.aborted || terminal === "cancelled") {
-            yield {
-                protocolVersion: 2,
-                type: "message.update",
-                payload: {
-                    ...gatewayMessage(state, "final", state.assistantItemId),
-                    role: "assistant",
-                    status: "stopped",
-                    text: state.assistantText,
-                    channel: "final"
-                }
-            };
-            yield {
-                protocolVersion: 2,
-                type: "run.cancelled",
-                payload: { reason: String(req.signal?.reason ?? "openclaw_aborted") }
-            };
-            return;
-        }
-        if (terminal !== "completed")
+        if (resourceFailure)
+            throw resourceFailure;
+        if (terminal !== "completed" && terminal !== "cancelled")
             throw new Error("OpenClaw Gateway stream ended without a terminal lifecycle event");
-        yield {
-            protocolVersion: 2,
-            type: "message.update",
-            payload: {
-                ...gatewayMessage(state, "final", state.assistantItemId),
-                role: "assistant",
-                status: "completed",
-                text: state.assistantText,
-                channel: "final"
-            }
-        };
-        yield { protocolVersion: 2, type: "run.completed", payload: {} };
+        yield* terminalEvents(terminal);
     }
     catch (error) {
-        if (req.signal?.aborted) {
-            if (!agentAccepted) {
-                yield {
-                    protocolVersion: 2,
-                    type: "message.update",
-                    payload: {
-                        ...gatewayMessage(state, "final", state.assistantItemId),
-                        role: "assistant",
-                        status: "stopped",
-                        text: state.assistantText,
-                        channel: "final"
-                    }
-                };
-                yield {
-                    protocolVersion: 2,
-                    type: "run.cancelled",
-                    payload: { reason: String(req.signal.reason ?? "openclaw_aborted_before_dispatch") }
-                };
+        let message = resourceFailure?.message ?? (error instanceof Error ? error.message : String(error));
+        if (!resourceFailure && terminal) {
+            yield* terminalEvents(terminal, message);
+            return;
+        }
+        if (!resourceFailure && req.signal?.aborted) {
+            if (!agentDispatched) {
+                yield* terminalEvents("cancelled");
                 return;
             }
-            let recoveryClient;
             try {
-                const abortParams = {
-                    key: providerSessionKey,
-                    runId: acceptedRunId,
-                    agentId: invocation.agentId
-                };
-                let controlClient = client;
-                try {
-                    await controlClient.request("sessions.abort", abortParams, { timeoutMs: 5_000 });
-                }
-                catch {
-                    recoveryClient = clientFactory(invocation.gateway);
-                    assertRuntimeGatewayContract(await recoveryClient.connect());
-                    controlClient = recoveryClient;
-                    await controlClient.request("sessions.abort", abortParams, { timeoutMs: 5_000 });
-                }
-                await waitForConfirmedTerminal(controlClient, acceptedRunId, "cancelled", Date.now() + 30_000);
-                yield {
-                    protocolVersion: 2,
-                    type: "message.update",
-                    payload: {
-                        ...gatewayMessage(state, "final", state.assistantItemId),
-                        role: "assistant",
-                        status: "stopped",
-                        text: state.assistantText,
-                        channel: "final"
-                    }
-                };
-                yield {
-                    protocolVersion: 2,
-                    type: "run.cancelled",
-                    payload: { reason: String(req.signal.reason ?? "openclaw_aborted") }
-                };
+                await confirmCancellation();
             }
             catch (abortError) {
-                const message = abortError instanceof Error
-                    ? abortError.message
-                    : "OpenClaw Gateway abort confirmation failed";
-                yield {
-                    protocolVersion: 2,
-                    type: "message.update",
-                    payload: {
-                        ...gatewayMessage(state, "final", state.assistantItemId),
-                        role: "assistant",
-                        status: "failed",
-                        text: state.assistantText,
-                        channel: "final"
-                    }
-                };
-                yield {
-                    protocolVersion: 2,
-                    type: "run.failed",
-                    payload: { message, adapterType: "openclaw" }
-                };
-            }
-            finally {
-                await recoveryClient?.close();
+                message =
+                    abortError instanceof Error
+                        ? abortError.message
+                        : "OpenClaw Gateway abort confirmation failed";
             }
+            yield* terminalEvents(terminal ?? "failed", message);
             return;
         }
-        let message = error instanceof Error ? error.message : String(error);
-        if (!resourceFailure && agentAccepted && terminal !== "failed" && terminal !== "cancelled") {
+        if (!resourceFailure && agentAccepted) {
             const recoveryClient = clientFactory(invocation.gateway);
             try {
-                assertRuntimeGatewayContract(await recoveryClient.connect());
-                await waitForConfirmedTerminal(recoveryClient, acceptedRunId, "completed", invocation.reconciliationDeadlineAt);
-                yield {
-                    protocolVersion: 2,
-                    type: "message.update",
-                    payload: {
-                        ...gatewayMessage(state, "final", state.assistantItemId),
-                        role: "assistant",
-                        status: "completed",
-                        text: state.assistantText,
-                        channel: "final"
-                    }
-                };
-                yield { protocolVersion: 2, type: "run.completed", payload: {} };
-                return;
+                resolveGatewayContract(await recoveryClient.connect());
+                const confirmed = await waitForConfirmedTerminal(recoveryClient, acceptedRunId, undefined, invocation.reconciliationDeadlineAt);
+                terminal ??= confirmed;
+                message = `OpenClaw Gateway confirmed a failed run after disconnect: ${message}`;
             }
             catch (recoveryError) {
                 const detail = recoveryError instanceof Error ? recoveryError.message : "unknown reconciliation failure";
@@ -872,18 +887,7 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
                 await recoveryClient.close();
             }
         }
-        yield {
-            protocolVersion: 2,
-            type: "message.update",
-            payload: {
-                ...gatewayMessage(state, "final", state.assistantItemId),
-                role: "assistant",
-                status: "failed",
-                text: state.assistantText,
-                channel: "final"
-            }
-        };
-        yield { protocolVersion: 2, type: "run.failed", payload: { message, adapterType: "openclaw" } };
+        yield* terminalEvents(resourceFailure ? "failed" : (terminal ?? "failed"), resourceFailure?.message ?? message);
     }
     finally {
         req.signal?.removeEventListener("abort", onAbort);
@@ -900,7 +904,7 @@ export function createOpenClawAdapter({ clientFactory = (options) => new OpenCla
         let client;
         try {
             client = clientFactory(await resolveOpenClawGateway(options?.providerOptions));
-            assertRuntimeGatewayContract(await client.connect());
+            resolveGatewayContract(await client.connect());
             await client.request("agents.list", {});
             return { available: true, command: "openclaw-gateway" };
         }

package/node_modules/@mininglamp-oss/octo-runtime-adapter-openclaw/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-openclaw",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.1.1",
-    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.1",
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.3",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.3",
     "ws": "8.22.0"
   },
   "types": "./dist/index.d.ts",