@mininglamp-oss/octo-runtime 1.1.1 → 1.1.3

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

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-kimi-code",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.1"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.3"
   }
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-mcode",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.1"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.3"
   }
 }

package/node_modules/@mininglamp-oss/octo-runtime-adapter-openclaw/dist/compatibility.d.ts

@@ -0,0 +1,24 @@
+import type { ApprovalMode } from "@mininglamp-oss/octo-runtime-protocol";
+type JsonRecord = Record<string, unknown>;
+export type GatewayTerminal = "completed" | "failed" | "cancelled";
+export interface GatewayContract {
+    version: string;
+    family: "legacy" | "session-permissions";
+    approvalTransport: boolean;
+    scopes?: readonly string[];
+}
+export interface GatewayPermissionPolicy {
+    effective: "ask" | "full_access";
+    fallbackReason?: string;
+}
+/** 每条连接以真实 hello 选择固定源码核对过的合同；v4 不表示请求字段相同。 */
+export declare function resolveGatewayContract(value: unknown): GatewayContract;
+/** 用户已授权 ask 不可用时向 full 回退；原始请求与 Context 不随 effective 改写。 */
+export declare function resolveGatewayPermission(contract: GatewayContract, requested: ApprovalMode): GatewayPermissionPolicy;
+export declare function gatewayCreateParams(contract: GatewayContract, policy: GatewayPermissionPolicy, params: JsonRecord, requestId: string, thinking: unknown): JsonRecord;
+export declare function gatewayLegacyPermissionParams(key: string): JsonRecord;
+/** 同一执行的中间回执在 RPC 等待、终态归一化和对账中使用同一判定。 */
+export declare function isGatewayRunPending(value: unknown): boolean;
+/** RPC 最终回执、lifecycle 与 agent.wait 共用归一化；超时归因优先于 abort 清理。 */
+export declare function gatewayTerminal(value: unknown, source: "wait" | "final" | "lifecycle"): GatewayTerminal | undefined;
+export {};

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

@@ -0,0 +1,181 @@
+const LEGACY_RELEASES = [
+    "2026.6.11",
+    "2026.7.1",
+    "2026.7.1-1",
+    "2026.7.1-2",
+    "2026.7.33",
+    "2026.7.34",
+    "2026.7.35"
+];
+const SESSION_PERMISSION_RELEASES = [
+    "2026.8.1",
+    "2026.8.2",
+    "2026.8.33",
+    "2026.8.34",
+    "2026.8.35",
+    "2026.9.1",
+    "2026.9.2",
+    "2026.9.3",
+    "2026.9.4",
+    "2026.9.5",
+    "2026.9.6",
+    "2026.9.7",
+    "2026.9.8",
+    "2026.9.9",
+    "2026.9.33",
+    "2026.10.1",
+    "2026.10.2",
+    "2026.10.3",
+    "2026.10.4",
+    "2026.10.5"
+];
+const RELEASES = new Map([
+    ...LEGACY_RELEASES.map((version) => [version, "legacy"]),
+    ...SESSION_PERMISSION_RELEASES.map((version) => [version, "session-permissions"])
+]);
+const EXECUTION_METHODS = [
+    "agents.list",
+    "sessions.create",
+    "sessions.messages.subscribe",
+    "agent",
+    "agent.wait",
+    "sessions.abort"
+];
+const APPROVAL_METHODS = ["exec.approval.list", "exec.approval.resolve"];
+const APPROVAL_EVENTS = ["exec.approval.requested", "exec.approval.resolved"];
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function strings(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+/** 每条连接以真实 hello 选择固定源码核对过的合同；v4 不表示请求字段相同。 */
+export function resolveGatewayContract(value) {
+    const hello = record(value);
+    const rawVersion = record(hello?.server)?.version;
+    const version = typeof rawVersion === "string" && /^v?\d{4}\.\d{1,2}\.\d{1,2}(?:-\d{1,2})?$/.test(rawVersion)
+        ? rawVersion.replace(/^v/, "")
+        : "unknown";
+    const fail = (reason) => {
+        const displayVersion = typeof rawVersion === "string" && /^[A-Za-z0-9.+_-]{1,80}$/.test(rawVersion)
+            ? rawVersion
+            : version;
+        throw new Error(`OPENCLAW_COMPATIBILITY_UNSUPPORTED: OpenClaw ${displayVersion}: ${reason}`);
+    };
+    if (hello?.protocol !== 4)
+        fail("unsupported Gateway protocol");
+    const family = RELEASES.get(version);
+    if (!family)
+        return fail("server.version has no verified contract");
+    const features = record(hello?.features);
+    const methods = strings(features?.methods);
+    const events = strings(features?.events);
+    for (const method of EXECUTION_METHODS) {
+        if (!methods.includes(method))
+            fail(`missing required method ${method}`);
+    }
+    if (family === "legacy" && !methods.includes("sessions.patch"))
+        fail("missing required method sessions.patch");
+    if (!events.includes("agent"))
+        fail("missing required agent event stream");
+    const auth = record(hello?.auth);
+    return {
+        version,
+        family,
+        approvalTransport: APPROVAL_METHODS.every((method) => methods.includes(method)) &&
+            APPROVAL_EVENTS.every((event) => events.includes(event)),
+        ...(Array.isArray(auth?.scopes) ? { scopes: strings(auth.scopes) } : {})
+    };
+}
+/** 用户已授权 ask 不可用时向 full 回退；原始请求与 Context 不随 effective 改写。 */
+export function resolveGatewayPermission(contract, requested) {
+    if (requested === "assisted")
+        throw new Error("APPROVAL_MODE_UNSUPPORTED: OpenClaw has no qualified assisted policy");
+    const fallbackReason = requested !== "ask"
+        ? undefined
+        : contract.family === "legacy"
+            ? "legacy_human_reviewer_unconfirmed"
+            : !contract.approvalTransport
+                ? "approval_transport_unavailable"
+                : contract.scopes &&
+                    !contract.scopes.includes("operator.approvals") &&
+                    !contract.scopes.includes("operator.admin")
+                    ? "approval_scope_unavailable"
+                    : undefined;
+    const effective = requested === "ask" && !fallbackReason ? "ask" : "full_access";
+    if (effective === "full_access" &&
+        contract.family === "session-permissions" &&
+        contract.scopes &&
+        !contract.scopes.includes("operator.admin")) {
+        throw new Error(`OPENCLAW_PERMISSION_UNAVAILABLE: OpenClaw ${contract.version}: full requires operator.admin`);
+    }
+    return { effective, ...(fallbackReason ? { fallbackReason } : {}) };
+}
+export function gatewayCreateParams(contract, policy, params, requestId, thinking) {
+    if (contract.family === "legacy")
+        return { ...params };
+    return {
+        ...params,
+        permissionMode: policy.effective === "full_access" ? "full" : "guarded",
+        idempotencyKey: `${requestId}-session`,
+        ...(typeof thinking === "string" ? { thinkingLevel: thinking } : {})
+    };
+}
+export function gatewayLegacyPermissionParams(key) {
+    // 旧字段不能区分 ask 与 auto reviewer，使用已授权的免审批回退，不伪称人工 ask。
+    return { key, execSecurity: "full", execAsk: "off" };
+}
+/** 同一执行的中间回执在 RPC 等待、终态归一化和对账中使用同一判定。 */
+export function isGatewayRunPending(value) {
+    const response = record(value);
+    return (response?.pendingError === true ||
+        ["accepted", "in_flight", "queued", "pending", "running"].includes(String(response?.status)));
+}
+/** RPC 最终回执、lifecycle 与 agent.wait 共用归一化；超时归因优先于 abort 清理。 */
+export function gatewayTerminal(value, source) {
+    const response = record(value);
+    const meta = record(record(response?.result)?.meta);
+    const status = typeof response?.status === "string"
+        ? response.status
+        : source === "lifecycle"
+            ? response?.phase === "end"
+                ? "ok"
+                : response?.phase === "error"
+                    ? "error"
+                    : undefined
+            : undefined;
+    if (!status || isGatewayRunPending(response))
+        return undefined;
+    const reason = response?.stopReason ?? meta?.stopReason;
+    const timeoutPhase = response?.timeoutPhase ?? meta?.timeoutPhase;
+    const hardTimeout = ["preflight", "provider", "post_turn"].includes(String(timeoutPhase)) ||
+        (status === "timeout" &&
+            reason !== "restart" &&
+            (response?.providerStarted ?? meta?.providerStarted) === true);
+    if (hardTimeout)
+        return "failed";
+    const livenessValue = response?.livenessState ?? meta?.livenessState;
+    const liveness = typeof livenessValue === "string" ? livenessValue.trim().toLowerCase() : "";
+    const ended = typeof response?.endedAt === "number" && Number.isFinite(response.endedAt);
+    if (source === "wait" && status === "timeout" && !ended)
+        return undefined;
+    if (liveness === "blocked" || reason === "timeout")
+        return "failed";
+    if (reason === "restart" ||
+        reason === "aborted" ||
+        (status !== "ok" && (reason === "rpc" || reason === "stop")) ||
+        response?.aborted === true ||
+        meta?.aborted === true)
+        return "cancelled";
+    if (liveness === "abandoned")
+        return "failed";
+    if (status === "ok")
+        return "completed";
+    if (status === "error" || status === "timeout")
+        return "failed";
+    return undefined;
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-openclaw/dist/gateway.d.ts

@@ -17,6 +17,9 @@ export interface OpenClawGatewayEvent {
 export interface OpenClawGatewayHello {
     type: "hello-ok";
     protocol: number;
+    server?: {
+        version?: string;
+    };
     features?: {
         methods?: string[];
         events?: string[];
@@ -27,6 +30,12 @@ export interface OpenClawGatewayHello {
         role?: string;
     };
 }
+/** 保留原生错误码和 RPC，兼容判断不依赖拼接字符串或记录完整 details。 */
+export declare class OpenClawGatewayRpcError extends Error {
+    readonly code: string | undefined;
+    readonly method: string;
+    constructor(code: string | undefined, method: string, message: string);
+}
 export declare function createOpenClawDeviceIdentity(): OpenClawDeviceIdentity;
 /** Minimal authenticated Gateway RPC client. One instance owns exactly one WebSocket. */
 export declare class OpenClawGatewayClient {

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

@@ -1,5 +1,6 @@
 import { createHash, generateKeyPairSync, randomUUID, sign } from "node:crypto";
 import WebSocket from "ws";
+import { isGatewayRunPending } from "./compatibility.js";
 const PROTOCOL_VERSION = 4;
 const CLIENT_ID = "cli";
 const CLIENT_MODE = "cli";
@@ -24,13 +25,24 @@ function messageText(data) {
         return Buffer.concat(data).toString("utf8");
     return Buffer.from(data).toString("utf8");
 }
-function errorFromFrame(frame) {
+/** 保留原生错误码和 RPC，兼容判断不依赖拼接字符串或记录完整 details。 */
+export class OpenClawGatewayRpcError extends Error {
+    code;
+    method;
+    constructor(code, method, message) {
+        super(message);
+        this.code = code;
+        this.method = method;
+        this.name = "OpenClawGatewayRpcError";
+    }
+}
+function errorFromFrame(frame, method) {
     const native = record(frame.error);
     const message = typeof native?.message === "string" ? native.message : "OpenClaw Gateway request failed";
     const details = record(native?.details);
     const requestId = typeof details?.requestId === "string" ? ` (pairing request ${details.requestId})` : "";
     const code = typeof native?.code === "string" ? ` [${native.code}]` : "";
-    return new Error(`${message}${requestId}${code}`);
+    return new OpenClawGatewayRpcError(typeof native?.code === "string" ? native.code : undefined, method, `${message}${requestId}${code}`);
 }
 function withRequestId(error, requestId) {
     if (error.message.includes("request_id="))
@@ -171,8 +183,10 @@ export class OpenClawGatewayClient {
                     device: deviceProof(this.#options.device, this.#options.token, nonce, signedAt)
                 }, { timeoutMs }).then((value) => {
                     const hello = record(value);
-                    if (!hello || hello.type !== "hello-ok")
-                        throw new Error("OpenClaw Gateway returned an invalid hello response");
+                    if (!hello || hello.type !== "hello-ok") {
+                        finish(new Error("OpenClaw Gateway returned an invalid hello response"));
+                        return;
+                    }
                     this.#hello = hello;
                     finish(undefined, hello);
                 }, (error) => finish(error instanceof Error ? error : new Error("OpenClaw Gateway connect request failed")));
@@ -180,6 +194,8 @@ export class OpenClawGatewayClient {
         });
     }
     request(method, params, options = {}) {
+        if (options.signal?.aborted)
+            return Promise.reject(new Error(`OpenClaw Gateway request ${method} aborted`));
         const socket = this.#socket;
         if (!socket || socket.readyState !== WebSocket.OPEN) {
             return Promise.reject(new Error("OpenClaw Gateway is not connected"));
@@ -187,6 +203,7 @@ export class OpenClawGatewayClient {
         const id = randomUUID();
         return new Promise((resolve, reject) => {
             const pending = {
+                method,
                 resolve,
                 reject,
                 expectFinal: options.expectFinal === true,
@@ -199,6 +216,7 @@ export class OpenClawGatewayClient {
                 pending.timer = setTimeout(() => {
                     if (!this.#pending.delete(id))
                         return;
+                    pending.cleanup?.();
                     reject(new Error(`OpenClaw Gateway request ${method} timed out after ${timeoutMs}ms`));
                 }, timeoutMs);
                 pending.timer.unref?.();
@@ -211,8 +229,6 @@ export class OpenClawGatewayClient {
                 pending.cleanup?.();
                 reject(new Error(`OpenClaw Gateway request ${method} aborted`));
             };
-            if (options.signal?.aborted)
-                return abort();
             options.signal?.addEventListener("abort", abort, { once: true });
             pending.cleanup = () => options.signal?.removeEventListener("abort", abort);
             this.#pending.set(id, pending);
@@ -278,7 +294,7 @@ export class OpenClawGatewayClient {
         if (!pending)
             return;
         const payload = record(frame.payload);
-        if (frame.ok === true && pending.expectFinal && payload?.status === "accepted") {
+        if (frame.ok === true && pending.expectFinal && isGatewayRunPending(payload)) {
             pending.accepted?.(frame.payload);
             return;
         }
@@ -289,7 +305,7 @@ export class OpenClawGatewayClient {
         if (frame.ok === true)
             pending.resolve(frame.payload);
         else
-            pending.reject(errorFromFrame(frame));
+            pending.reject(errorFromFrame(frame, pending.method));
     }
     #failPending(error) {
         for (const pending of this.#pending.values()) {