@artinet/cruiser 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -17,6 +17,7 @@
  * | Claude     | `@artinet/cruiser/claude`      | {@link ClaudeAgent}  |
  * | LangChain  | `@artinet/cruiser/langchain`   | {@link ReactAgent}   |
  * | Mastra     | `@artinet/cruiser/mastra`      | {@link MastraAgent}  |
+ * | OpenClaw   | `@artinet/cruiser/openclaw`    | {@link OpenClawAgent}|
  * | OpenAI     | `@artinet/cruiser/openai`      | {@link OpenAIAgent}  |
  * | Strands    | `@artinet/cruiser/strands`     | {@link StrandsAgent} |
  *

package/dist/index.js

@@ -17,6 +17,7 @@
  * | Claude     | `@artinet/cruiser/claude`      | {@link ClaudeAgent}  |
  * | LangChain  | `@artinet/cruiser/langchain`   | {@link ReactAgent}   |
  * | Mastra     | `@artinet/cruiser/mastra`      | {@link MastraAgent}  |
+ * | OpenClaw   | `@artinet/cruiser/openclaw`    | {@link OpenClawAgent}|
  * | OpenAI     | `@artinet/cruiser/openai`      | {@link OpenAIAgent}  |
  * | Strands    | `@artinet/cruiser/strands`     | {@link StrandsAgent} |
  *

package/dist/mastra/index.d.ts

@@ -40,9 +40,9 @@
  *
  * @see {@link https://mastra.ai/docs} Mastra Documentation
  */
-import { OutputSchema } from "@mastra/core/stream";
-import { Agent as MastraAgent, AgentExecutionOptions } from "@mastra/core/agent";
-import { Dock, Park } from "../corsair.js";
+import { OutputSchema } from '@mastra/core/stream';
+import { Agent as MastraAgent, AgentExecutionOptions } from '@mastra/core/agent';
+import { Dock, Park } from '../corsair.js';
 /**
  * Docks a Mastra agent onto artinet.
  *
@@ -104,8 +104,8 @@ import { Dock, Park } from "../corsair.js";
  * });
  * ```
  */
-export declare const dock: Dock<MastraAgent, AgentExecutionOptions<OutputSchema | undefined, "aisdk" | "mastra">>;
+export declare const dock: Dock<MastraAgent, AgentExecutionOptions<OutputSchema | undefined>>;
 /**
  * @deprecated Use {@link dock} instead.
  */
-export declare const park: Park<MastraAgent, AgentExecutionOptions<OutputSchema | undefined, "aisdk" | "mastra">>;
+export declare const park: Park<MastraAgent, AgentExecutionOptions<OutputSchema | undefined>>;

package/dist/mastra/index.js

@@ -40,9 +40,9 @@
  *
  * @see {@link https://mastra.ai/docs} Mastra Documentation
  */
-import * as sdk from "@artinet/sdk";
-import { getAgentCard, convertToCoreMessage } from "./utils.js";
-import { v4 as uuidv4 } from "uuid";
+import * as sdk from '@artinet/sdk';
+import { getAgentCard, convertToCoreMessage } from './utils.js';
+import { v4 as uuidv4 } from 'uuid';
 /**
  * Docks a Mastra agent onto artinet.
  *
@@ -135,7 +135,7 @@ export const dock = async (agent, card, options) => {
             contextId: task.contextId,
             message: sdk.describe.message({
                 messageId: uuidv4(),
-                role: "agent",
+                role: 'agent',
                 parts: [sdk.describe.part.text(result.text)],
                 metadata,
             }),

package/dist/mastra/utils.d.ts

@@ -9,10 +9,10 @@
  *
  * @see {@link https://github.com/mastra-ai/mastra} Mastra Source
  */
-import * as sdk from "@artinet/sdk";
-import { AgentExecutionOptions, Agent as MastraAgent } from "@mastra/core/agent";
-import { CoreMessage } from "@mastra/core/llm";
-import { OutputSchema } from "@mastra/core/stream";
+import * as sdk from '@artinet/sdk';
+import { AgentExecutionOptions, Agent as MastraAgent } from '@mastra/core/agent';
+import { CoreMessage } from '@mastra/core/llm';
+import { OutputSchema } from '@mastra/core/stream';
 /**
  * Builds an {@link sdk.A2A.AgentCard} from Mastra agent configuration.
  *
@@ -36,10 +36,10 @@ import { OutputSchema } from "@mastra/core/stream";
  * });
  * ```
  */
-export declare function getAgentCard<OUTPUT extends OutputSchema = undefined, FORMAT extends "aisdk" | "mastra" = "mastra">({ agent, card, options: _options, }: {
+export declare function getAgentCard<OUTPUT extends OutputSchema = undefined>({ agent, card, options: _options, }: {
     agent: MastraAgent;
     card?: sdk.A2A.AgentCardParams;
-    options?: AgentExecutionOptions<OUTPUT, FORMAT>;
+    options?: AgentExecutionOptions<OUTPUT>;
 }): Promise<sdk.A2A.AgentCard>;
 /**
  * Converts an {@link sdk.A2A.Message} to Mastra's {@link CoreMessage} format.

package/dist/mastra/utils.js

@@ -9,7 +9,7 @@
  *
  * @see {@link https://github.com/mastra-ai/mastra} Mastra Source
  */
-import * as sdk from "@artinet/sdk";
+import * as sdk from '@artinet/sdk';
 /**
  * Converts Mastra {@link SystemMessage} instructions to a plain string.
  *
@@ -27,25 +27,25 @@ import * as sdk from "@artinet/sdk";
  */
 function convertInstructionsToString(message) {
     if (!message) {
-        return "";
+        return '';
     }
-    if (typeof message === "string") {
+    if (typeof message === 'string') {
         return message;
     }
     if (Array.isArray(message)) {
         return message
             .map((m) => {
-            if (typeof m === "string") {
+            if (typeof m === 'string') {
                 return m;
             }
             // Safely extract content from message objects
-            return typeof m.content === "string" ? m.content : "";
+            return typeof m.content === 'string' ? m.content : '';
         })
             .filter((content) => content) // Remove empty strings
-            .join("\n");
+            .join('\n');
     }
     // Handle single message object - safely extract content
-    return typeof message.content === "string" ? message.content : "";
+    return typeof message.content === 'string' ? message.content : '';
 }
 /**
  * Builds an {@link sdk.A2A.AgentCard} from Mastra agent configuration.
@@ -71,23 +71,23 @@ function convertInstructionsToString(message) {
  * ```
  */
 export async function getAgentCard({ agent, card, options: _options, }) {
-    const [instructions, tools] = await Promise.all([agent.getInstructions(), agent.getTools()]);
+    const [instructions, tools = {}] = await Promise.all([agent.getInstructions(), agent.listTools?.() ?? Promise.resolve({})]);
     const agentCard = sdk.describe.card({
         name: agent.id,
-        ...(typeof card === "string" ? { name: card } : card),
+        ...(typeof card === 'string' ? { name: card } : card),
         description: convertInstructionsToString(instructions),
         capabilities: {
             streaming: true,
             pushNotifications: true,
             stateTransitionHistory: false,
         },
-        defaultInputModes: ["text"],
-        defaultOutputModes: ["text"],
+        defaultInputModes: ['text'],
+        defaultOutputModes: ['text'],
         skills: Object.entries(tools).map(([toolId, tool]) => ({
             id: toolId,
             name: toolId,
             description: tool.description || `Tool: ${toolId}`,
-            tags: ["tool"],
+            tags: ['tool'],
         })),
     });
     return agentCard;
@@ -112,7 +112,7 @@ export async function getAgentCard({ agent, card, options: _options, }) {
  */
 export function convertToCoreMessage(message) {
     return {
-        role: message.role === "user" ? "user" : "assistant",
+        role: message.role === 'user' ? 'user' : 'assistant',
         content: message.parts.map((msg) => convertToCoreMessagePart(msg)),
     };
 }
@@ -131,21 +131,21 @@ export function convertToCoreMessage(message) {
  */
 function convertToCoreMessagePart(part) {
     switch (part.kind) {
-        case "text":
+        case 'text':
             return {
-                type: "text",
+                type: 'text',
                 text: part.text,
             };
-        case "file":
+        case 'file':
             return {
-                type: "file",
-                data: "uri" in part.file && part.file.uri
+                type: 'file',
+                data: 'uri' in part.file && part.file.uri
                     ? new URL(part.file.uri)
                     : /**Appeasing the type system */
                         part.file.bytes,
-                mimeType: part.file.mimeType ?? "unknown",
+                mimeType: part.file.mimeType ?? 'unknown',
             };
-        case "data":
-            throw new Error("Data parts are not supported in core messages");
+        case 'data':
+            throw new Error('Data parts are not supported in core messages');
     }
 }

package/dist/openclaw/auth.d.ts

@@ -0,0 +1,48 @@
+import type { OpenClawAgent } from './utils.js';
+type StoredAuthFile = {
+    version: 1;
+    device?: {
+        id: string;
+        publicKey: string;
+        privateKeyPem: string;
+    };
+    tokens?: {
+        operator?: {
+            token: string;
+            role?: string;
+            scopes?: string[];
+            updatedAtMs: number;
+        };
+    };
+};
+export type ResolvedDeviceIdentity = {
+    id: string;
+    publicKey: string;
+    privateKeyPem: string;
+};
+export declare function resolveAuthFilePath(agent: OpenClawAgent): string | undefined;
+export declare function readStoredAuth(path: string | undefined): StoredAuthFile | undefined;
+export declare function writeStoredAuth(path: string | undefined, auth: StoredAuthFile): void;
+export declare function resolveOrCreateDeviceIdentity({ agent, authFilePath, }: {
+    agent: OpenClawAgent;
+    authFilePath: string | undefined;
+}): ResolvedDeviceIdentity | undefined;
+export declare function createSignedDevicePayload({ identity, scopes, token, nonce, }: {
+    identity: ResolvedDeviceIdentity;
+    scopes: string[];
+    token?: string;
+    nonce?: string;
+}): {
+    id: string;
+    publicKey: string;
+    signature: string;
+    signedAt: number;
+    nonce?: string;
+};
+export declare function persistConnectAuth({ authFilePath, payload, scopes, deviceIdentity, }: {
+    authFilePath: string | undefined;
+    payload: unknown;
+    scopes: string[];
+    deviceIdentity?: ResolvedDeviceIdentity;
+}): void;
+export {};

package/dist/openclaw/auth.js

@@ -0,0 +1,152 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+function base64UrlEncode(buffer) {
+    return buffer.toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/g, '');
+}
+function derivePublicKeyRawFromPem(publicKeyPem) {
+    const key = createPublicKey(publicKeyPem);
+    const spki = key.export({ type: 'spki', format: 'der' });
+    if (spki.length === ED25519_SPKI_PREFIX.length + 32 &&
+        spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+        return spki.subarray(ED25519_SPKI_PREFIX.length);
+    }
+    return spki;
+}
+function fingerprintPublicKey(publicKeyBase64Url) {
+    return createHash('sha256')
+        .update(Buffer.from(publicKeyBase64Url.replaceAll('-', '+').replaceAll('_', '/'), 'base64'))
+        .digest('hex');
+}
+function buildDeviceAuthPayload({ version, deviceId, clientId, clientMode, role, scopes, signedAt, token, nonce, }) {
+    const base = [version, deviceId, clientId, clientMode, role, scopes.join(','), String(signedAt), token ?? ''];
+    if (version === 'v2') {
+        base.push(nonce ?? '');
+    }
+    return base.join('|');
+}
+export function resolveAuthFilePath(agent) {
+    if (agent.autoDeviceAuth === false) {
+        return undefined;
+    }
+    if (agent.authFilePath && agent.authFilePath.trim().length > 0) {
+        return agent.authFilePath.trim();
+    }
+    return join(homedir(), 'artinet-openclaw.auth');
+}
+export function readStoredAuth(path) {
+    if (!path || !existsSync(path)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (parsed.version !== 1) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeStoredAuth(path, auth) {
+    if (!path) {
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(auth, null, 2)}\n`, { encoding: 'utf8' });
+}
+export function resolveOrCreateDeviceIdentity({ agent, authFilePath, }) {
+    const manual = agent.device;
+    if (manual?.id && manual.publicKey && manual.privateKeyPem) {
+        return {
+            id: manual.id,
+            publicKey: manual.publicKey,
+            privateKeyPem: manual.privateKeyPem,
+        };
+    }
+    const stored = readStoredAuth(authFilePath);
+    if (stored?.device?.id && stored.device.publicKey && stored.device.privateKeyPem) {
+        return stored.device;
+    }
+    if (agent.autoDeviceAuth === false) {
+        return undefined;
+    }
+    const keyPair = generateKeyPairSync('ed25519');
+    const publicKeyPem = keyPair.publicKey.export({ type: 'spki', format: 'pem' }).toString();
+    const privateKeyPem = keyPair.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
+    const publicKey = base64UrlEncode(derivePublicKeyRawFromPem(publicKeyPem));
+    const identity = {
+        id: fingerprintPublicKey(publicKey),
+        publicKey,
+        privateKeyPem,
+    };
+    const nextAuth = stored ?? { version: 1 };
+    nextAuth.device = identity;
+    writeStoredAuth(authFilePath, nextAuth);
+    return identity;
+}
+export function createSignedDevicePayload({ identity, scopes, token, nonce, }) {
+    const signedAt = Date.now();
+    const version = nonce ? 'v2' : 'v1';
+    const payload = buildDeviceAuthPayload({
+        version,
+        deviceId: identity.id,
+        clientId: 'cli',
+        clientMode: 'cli',
+        role: 'operator',
+        scopes,
+        signedAt,
+        token,
+        nonce,
+    });
+    const signature = base64UrlEncode(sign(null, Buffer.from(payload, 'utf8'), createPrivateKey(identity.privateKeyPem)));
+    return {
+        id: identity.id,
+        publicKey: identity.publicKey,
+        signature,
+        signedAt,
+        ...(nonce ? { nonce } : {}),
+    };
+}
+export function persistConnectAuth({ authFilePath, payload, scopes, deviceIdentity, }) {
+    if (!authFilePath) {
+        return;
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const record = payload;
+    const auth = record.auth;
+    if (!auth || typeof auth !== 'object' || Array.isArray(auth)) {
+        return;
+    }
+    const authRecord = auth;
+    const deviceToken = authRecord.deviceToken;
+    if (typeof deviceToken !== 'string' || deviceToken.trim().length === 0) {
+        return;
+    }
+    const role = typeof authRecord.role === 'string' ? authRecord.role : 'operator';
+    const resolvedScopes = Array.isArray(authRecord.scopes)
+        ? authRecord.scopes.filter((scope) => typeof scope === 'string')
+        : scopes;
+    const existing = readStoredAuth(authFilePath) ?? { version: 1 };
+    const next = {
+        ...existing,
+        tokens: {
+            ...(existing.tokens ?? {}),
+            operator: {
+                token: deviceToken,
+                role,
+                scopes: resolvedScopes,
+                updatedAtMs: Date.now(),
+            },
+        },
+    };
+    if (deviceIdentity) {
+        next.device = deviceIdentity;
+    }
+    writeStoredAuth(authFilePath, next);
+}

package/dist/openclaw/client.d.ts

@@ -0,0 +1,37 @@
+import type { OpenClawAgent, OpenClawResult } from './utils.js';
+export declare class OpenClawGatewayClient {
+    private readonly url;
+    private readonly authToken?;
+    private readonly authPassword?;
+    private readonly device?;
+    private readonly deviceIdentity?;
+    private readonly authFilePath;
+    private readonly scopes;
+    private readonly connectTimeoutMs;
+    private readonly clientId;
+    private socket;
+    private connectPromise;
+    private isConnected;
+    private connectRequestId;
+    private pendingRequests;
+    constructor({ url, authToken, authPassword, agent, device, scopes, connectTimeoutMs, }: {
+        url: string;
+        authToken?: string;
+        authPassword?: string;
+        agent: OpenClawAgent;
+        device?: OpenClawAgent['device'];
+        scopes?: string[];
+        connectTimeoutMs: number;
+    });
+    ensureConnected(): Promise<void>;
+    requestAgentRun({ message, agentId, sessionKey, timeoutMs, }: {
+        message: string;
+        agentId: string;
+        sessionKey?: string;
+        timeoutMs: number;
+    }): Promise<OpenClawResult>;
+    private handleMessage;
+    private sendConnectRequest;
+    private sendFrame;
+    private rejectAllPending;
+}

package/dist/openclaw/client.js

@@ -0,0 +1,236 @@
+import { v4 as uuidv4 } from 'uuid';
+import { createSignedDevicePayload, persistConnectAuth, readStoredAuth, resolveAuthFilePath, resolveOrCreateDeviceIdentity, } from './auth.js';
+export class OpenClawGatewayClient {
+    url;
+    authToken;
+    authPassword;
+    device;
+    deviceIdentity;
+    authFilePath;
+    scopes;
+    connectTimeoutMs;
+    clientId;
+    socket;
+    connectPromise;
+    isConnected = false;
+    connectRequestId;
+    pendingRequests = new Map();
+    constructor({ url, authToken, authPassword, agent, device, scopes, connectTimeoutMs, }) {
+        this.url = url;
+        this.authFilePath = resolveAuthFilePath(agent);
+        const storedAuth = readStoredAuth(this.authFilePath);
+        this.authToken = authToken ?? storedAuth?.tokens?.operator?.token;
+        this.authPassword = authPassword;
+        this.device = device;
+        this.deviceIdentity = resolveOrCreateDeviceIdentity({ agent, authFilePath: this.authFilePath });
+        const requestedScopes = scopes ?? [];
+        const requiredScopes = ['operator.read', 'operator.write'];
+        this.scopes = Array.from(new Set([...requiredScopes, ...requestedScopes]));
+        this.connectTimeoutMs = connectTimeoutMs;
+        this.clientId = uuidv4();
+    }
+    async ensureConnected() {
+        if (this.isConnected && this.socket?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        this.connectPromise = new Promise((resolve, reject) => {
+            const socket = new WebSocket(this.url);
+            this.socket = socket;
+            const connectTimeout = setTimeout(() => {
+                reject(new Error('OpenClaw gateway connect timeout'));
+            }, this.connectTimeoutMs);
+            let challengeFallback;
+            function cleanupConnect() {
+                clearTimeout(connectTimeout);
+                if (challengeFallback) {
+                    clearTimeout(challengeFallback);
+                    challengeFallback = undefined;
+                }
+            }
+            socket.onopen = () => {
+                challengeFallback = setTimeout(() => {
+                    this.sendConnectRequest();
+                }, 1_000);
+            };
+            socket.onmessage = (event) => {
+                this.handleMessage(event.data, resolve, reject, cleanupConnect);
+            };
+            socket.onerror = () => {
+                cleanupConnect();
+                reject(new Error('OpenClaw gateway socket error'));
+            };
+            socket.onclose = () => {
+                this.isConnected = false;
+                this.connectPromise = undefined;
+                this.connectRequestId = undefined;
+                this.socket = undefined;
+                this.rejectAllPending(new Error('OpenClaw gateway socket closed'));
+            };
+        })
+            .catch((error) => {
+            this.connectPromise = undefined;
+            throw error;
+        })
+            .then(() => undefined);
+        return this.connectPromise;
+    }
+    async requestAgentRun({ message, agentId, sessionKey, timeoutMs, }) {
+        await this.ensureConnected();
+        const requestId = uuidv4();
+        const idempotencyKey = uuidv4();
+        const frame = {
+            type: 'req',
+            id: requestId,
+            method: 'agent',
+            params: {
+                message,
+                agentId,
+                sessionKey,
+                deliver: false,
+                idempotencyKey,
+            },
+        };
+        const responsePromise = new Promise((resolve, reject) => {
+            this.pendingRequests.set(requestId, {
+                expectFinal: true,
+                resolve,
+                reject,
+            });
+        });
+        this.sendFrame(frame);
+        const timeout = new Promise((_, reject) => {
+            setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error('OpenClaw gateway request timeout'));
+            }, timeoutMs);
+        });
+        const payload = (await Promise.race([responsePromise, timeout]));
+        if (payload.status && payload.status !== 'ok') {
+            const details = payload.error?.message ?? 'unknown error';
+            throw new Error(`OpenClaw agent failed: ${payload.status}: ${details}`);
+        }
+        return (payload.result ?? payload);
+    }
+    handleMessage(raw, connectResolve, connectReject, cleanupConnect) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const frame = parsed;
+        if (frame.type === 'event' && frame.event === 'connect.challenge') {
+            this.sendConnectRequest(frame.payload?.nonce);
+            return;
+        }
+        if (frame.type !== 'res' || !frame.id) {
+            return;
+        }
+        const response = parsed;
+        if (frame.id === this.connectRequestId) {
+            cleanupConnect();
+            if (!response.ok) {
+                connectReject(new Error(response.error?.message ?? 'OpenClaw gateway connect rejected'));
+                return;
+            }
+            persistConnectAuth({
+                authFilePath: this.authFilePath,
+                payload: response.payload,
+                scopes: this.scopes,
+                deviceIdentity: this.deviceIdentity,
+            });
+            this.isConnected = true;
+            connectResolve();
+            return;
+        }
+        const pending = this.pendingRequests.get(frame.id);
+        if (!pending) {
+            return;
+        }
+        const payload = response.payload;
+        if (pending.expectFinal && payload?.status === 'accepted') {
+            return;
+        }
+        this.pendingRequests.delete(frame.id);
+        if (!response.ok) {
+            pending.reject(new Error(response.error?.message ?? 'OpenClaw gateway request failed'));
+            return;
+        }
+        pending.resolve(response.payload);
+    }
+    sendConnectRequest(nonce) {
+        if (this.connectRequestId) {
+            return;
+        }
+        const params = {
+            minProtocol: 3,
+            maxProtocol: 3,
+            client: {
+                id: 'cli',
+                displayName: 'cruiser-openclaw',
+                version: '0.1.5',
+                platform: 'node',
+                mode: 'cli',
+                instanceId: this.clientId,
+            },
+            role: 'operator',
+            scopes: this.scopes,
+            caps: [],
+            commands: [],
+            permissions: {},
+            locale: 'en-US',
+            userAgent: 'artinet-cruiser/openclaw',
+        };
+        if (this.authToken || this.authPassword) {
+            params.auth = {
+                ...(this.authToken ? { token: this.authToken } : {}),
+                ...(this.authPassword ? { password: this.authPassword } : {}),
+            };
+        }
+        const signedDevice = this.deviceIdentity
+            ? createSignedDevicePayload({
+                identity: this.deviceIdentity,
+                scopes: this.scopes,
+                token: this.authToken,
+                nonce,
+            })
+            : undefined;
+        if (signedDevice) {
+            params.device = signedDevice;
+        }
+        else if (this.device) {
+            const deviceNonce = nonce ?? this.device.nonce;
+            params.device = {
+                id: this.device.id,
+                publicKey: this.device.publicKey,
+                signature: this.device.signature,
+                signedAt: this.device.signedAt,
+                ...(deviceNonce ? { nonce: deviceNonce } : {}),
+            };
+        }
+        const requestId = uuidv4();
+        this.connectRequestId = requestId;
+        this.sendFrame({
+            type: 'req',
+            id: requestId,
+            method: 'connect',
+            params,
+        });
+    }
+    sendFrame(frame) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error('OpenClaw gateway is not connected');
+        }
+        this.socket.send(JSON.stringify(frame));
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+}