@winmatrix/agent-sdk 0.1.0

package/dist/adapters/openclaw/OpenClawAdapter.js

@@ -0,0 +1,798 @@
+/**
+ * OpenClawAdapter — 通过 WebSocket-RPC 连接本地 OpenClaw Gateway (port 18789)
+ *
+ * OpenClaw 是 Gateway 架构的智能体运行时，通过 WS-RPC 协议通信。
+ * 协议：connect.challenge → connect 握手 → chat.send 发消息 → chat/agent 事件流
+ *
+ * 使用 client.id: 'gateway-client' + client.mode: 'backend' 作为 loopback backend 客户端，
+ * 无需 device identity 签名。
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import WebSocket from 'ws';
+import { parseSkillMd } from '../../utils/parseSkillMd.js';
+// ── constants ──
+const PROTOCOL_VERSION = 3;
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_CONFIG = join(OPENCLAW_DIR, 'openclaw.json');
+/** eventQueue 上限，防止 wakeUp 丢失导致的内存泄漏 */
+const MAX_EVENT_QUEUE = 10_000;
+/** 判断事件帧是否为流终止事件（final/error），终止事件不应被丢弃 */
+function isStreamEndEvent(frame) {
+    if (frame.event === 'chat') {
+        const state = frame.payload?.state;
+        return state === 'final' || state === 'error';
+    }
+    if (frame.event === 'agent') {
+        const stream = typeof frame.payload?.stream === 'string'
+            ? frame.payload.stream
+            : '';
+        const data = frame.payload?.data;
+        if (stream === 'lifecycle') {
+            const phase = data?.phase;
+            return phase === 'end' || phase === 'error';
+        }
+        if (stream === 'error')
+            return true;
+    }
+    return false;
+}
+/** 递归提取嵌套对象或数组中的 text 字符串 */
+function extractText(obj) {
+    if (typeof obj === 'string')
+        return obj;
+    if (Array.isArray(obj)) {
+        const parts = [];
+        for (const item of obj) {
+            if (typeof item === 'string') {
+                parts.push(item);
+            }
+            else if (item && typeof item === 'object' && typeof item.text === 'string') {
+                parts.push(item.text);
+            }
+        }
+        return parts.join('');
+    }
+    if (!obj || typeof obj !== 'object')
+        return '';
+    const o = obj;
+    if (typeof o.text === 'string')
+        return o.text;
+    if (typeof o.content === 'string')
+        return o.content;
+    if (typeof o.delta === 'string')
+        return o.delta;
+    if (Array.isArray(o.content)) {
+        const parts = [];
+        for (const item of o.content) {
+            if (typeof item === 'string') {
+                parts.push(item);
+            }
+            else if (item && typeof item === 'object' && typeof item.text === 'string') {
+                parts.push(item.text);
+            }
+        }
+        return parts.join('');
+    }
+    return '';
+}
+/** 从 chat 事件 payload 提取文本 */
+function extractTextFromPayload(payload) {
+    const fromMessage = extractText(payload.message);
+    if (fromMessage)
+        return fromMessage;
+    if (Array.isArray(payload.messages)) {
+        const parts = [];
+        for (const m of payload.messages) {
+            const t = extractText(m);
+            if (t)
+                parts.push(t);
+        }
+        if (parts.length > 0)
+            return parts.join('');
+    }
+    if (typeof payload.content === 'string')
+        return payload.content;
+    if (typeof payload.text === 'string')
+        return payload.text;
+    if (typeof payload.delta === 'string')
+        return payload.delta;
+    const fromContent = extractText(payload.content);
+    if (fromContent)
+        return fromContent;
+    if (typeof payload.result === 'string')
+        return payload.result;
+    if (typeof payload.output === 'string')
+        return payload.output;
+    return '';
+}
+/**
+ * 从 agent assistant 事件 data 提取文本。
+ * 参照 server 端 extractAgentAssistantText — 覆盖 text/delta/content/chunk/messages/message/payload/result/response/output。
+ */
+export function extractAgentAssistantText(data) {
+    if (typeof data.text === 'string')
+        return data.text;
+    if (typeof data.delta === 'string')
+        return data.delta;
+    if (typeof data.content === 'string')
+        return data.content;
+    if (typeof data.chunk === 'string')
+        return data.chunk;
+    const fromMessages = extractTextFromMessages(data.messages);
+    if (fromMessages)
+        return fromMessages;
+    const fromMessage = extractText(data.message);
+    if (fromMessage)
+        return fromMessage;
+    const fromContent = extractText(data.content);
+    if (fromContent)
+        return fromContent;
+    const fromDelta = extractText(data.delta);
+    if (fromDelta)
+        return fromDelta;
+    const fromChunk = extractText(data.chunk);
+    if (fromChunk)
+        return fromChunk;
+    const fromPayload = extractText(data.payload);
+    if (fromPayload)
+        return fromPayload;
+    const fromResult = extractText(data.result);
+    if (fromResult)
+        return fromResult;
+    const fromResponse = extractText(data.response);
+    if (fromResponse)
+        return fromResponse;
+    const fromOutput = extractText(data.output);
+    if (fromOutput)
+        return fromOutput;
+    // deep extraction
+    const fromDeep = extractTextDeep(data);
+    if (fromDeep)
+        return fromDeep;
+    return '';
+}
+export function extractTextFromMessages(messages) {
+    if (!Array.isArray(messages))
+        return '';
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const item = messages[i];
+        if (!item || typeof item !== 'object')
+            continue;
+        const msg = item;
+        const role = typeof msg.role === 'string' ? msg.role.toLowerCase() : '';
+        if (role !== 'assistant' && role !== 'model')
+            continue;
+        const text = extractText(msg.content) || extractTextDeep(msg);
+        if (text)
+            return text;
+    }
+    return '';
+}
+export function extractTextDeep(obj, depth = 0) {
+    if (!obj || typeof obj !== 'object' || depth > 4)
+        return '';
+    const o = obj;
+    for (const key of ['text', 'content', 'delta', 'chunk', 'result', 'output', 'response', 'message']) {
+        const v = o[key];
+        if (typeof v === 'string' && v.trim())
+            return v;
+        if (v && typeof v === 'object') {
+            const inner = extractTextDeep(v, depth + 1);
+            if (inner)
+                return inner;
+        }
+    }
+    return '';
+}
+/** 从 ~/.openclaw/openclaw.json 读取 gateway token */
+function readGatewayTokenFromConfig() {
+    try {
+        if (!existsSync(OPENCLAW_CONFIG))
+            return undefined;
+        const raw = readFileSync(OPENCLAW_CONFIG, 'utf-8');
+        const cfg = JSON.parse(raw);
+        return cfg.gateway?.auth?.token || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * sessionKey 编码: agent:<agentId>:direct:<sessionKey>（参照 server toAgentSessionKey）。
+ * 若 sessionKey 已是 agent: 格式则不重复编码，避免双重包装。
+ */
+export function toAgentSessionKey(sessionKey, agentId) {
+    if (sessionKey.toLowerCase().startsWith('agent:'))
+        return sessionKey;
+    return `agent:${agentId}:direct:${sessionKey}`;
+}
+export class OpenClawAdapter {
+    meta = {
+        agentType: 'openclaw',
+        runtime: 'openclaw',
+        capabilities: {
+            streaming: true,
+            toolCall: true,
+            session: true,
+            cancellation: false,
+        },
+        tools: [],
+        skills: [],
+        toolCategories: {},
+    };
+    gatewayHost;
+    gatewayPort;
+    token;
+    mcpBridgeUrl;
+    mcpApiKey;
+    agentId;
+    constructor(config) {
+        const opts = config;
+        this.gatewayHost = opts?.gatewayHost ?? '127.0.0.1';
+        this.gatewayPort = opts?.gatewayPort ?? 18789;
+        this.token = opts?.token ?? readGatewayTokenFromConfig();
+        this.mcpBridgeUrl = opts?.mcpBridgeUrl;
+        this.mcpApiKey = opts?.mcpApiKey;
+        this.agentId = opts?.agentId;
+    }
+    get gatewayUrl() {
+        return `ws://${this.gatewayHost}:${this.gatewayPort}`;
+    }
+    // ── MCP config helpers ──
+    /**
+     * Write MCP server config to openclaw.json, merge with existing keys.
+     *
+     * 注意：本方法直接写 ~/.openclaw/openclaw.json 共享文件，不适用于同一 OpenClaw
+     * 实例上并发多任务场景。当前 daemon 方案 B 下每 agent 单任务串行执行，不会出现
+     * 并发写入竞态。若未来支持并发任务，需改为 per-task session 级 MCP 注入。
+     */
+    writeMCPConfig(token, configPath) {
+        if (!this.mcpBridgeUrl)
+            return;
+        const actualConfigPath = configPath ?? OPENCLAW_CONFIG;
+        try {
+            const cfgDir = dirname(actualConfigPath);
+            if (!existsSync(cfgDir))
+                mkdirSync(cfgDir, { recursive: true });
+            let cfg = {};
+            if (existsSync(actualConfigPath)) {
+                try {
+                    cfg = JSON.parse(readFileSync(actualConfigPath, 'utf-8'));
+                }
+                catch { /* overwrite */ }
+            }
+            const mcp = (cfg.mcp ?? {});
+            const servers = (mcp.servers ?? {});
+            const effectiveToken = token ?? this.mcpApiKey;
+            servers.winmatrix = {
+                url: this.mcpBridgeUrl,
+                transport: 'streamable-http',
+                ...(effectiveToken ? { headers: { Authorization: `Bearer ${effectiveToken}` } } : {}),
+            };
+            cfg.mcp = { ...mcp, servers };
+            writeFileSync(actualConfigPath, JSON.stringify(cfg, null, 2), 'utf-8');
+        }
+        catch {
+            // best-effort: Gateway 可能不在本机
+        }
+    }
+    // ── execute ──
+    async *execute(task, signal) {
+        const isOneshot = task.mode === 'oneshot';
+        let sessionId = task.sessionId;
+        // Write MCP config to openclaw.json before connect (per-task mcpToken takes priority).
+        // MCP 配置通过文件注入而非 chat.send params，因为 Gateway 从 openclaw.json 中
+        // mcp.servers.winmatrix 读取插件配置。前提：Gateway 支持热加载或 MCP 插件按需读取。
+        this.writeMCPConfig(task.mcpToken);
+        const gatewayHost = task.openclaw?.gatewayHost ?? this.gatewayHost;
+        const gatewayPort = task.openclaw?.gatewayPort ?? this.gatewayPort;
+        const gatewayUrl = `ws://${gatewayHost}:${gatewayPort}`;
+        let ws;
+        try {
+            ws = await this.authenticatedConnect(gatewayUrl, gatewayHost, signal);
+        }
+        catch (err) {
+            yield { type: 'error', message: `OpenClaw Gateway connection failed: ${err instanceof Error ? err.message : String(err)}` };
+            return;
+        }
+        // Build persistent handler infrastructure BEFORE chat.send
+        const pendingRequests = new Map();
+        const eventQueue = [];
+        let wakeUp = null;
+        let streamDone = false;
+        let finalized = false;
+        const persistHandler = (data) => {
+            try {
+                const frame = JSON.parse(data.toString());
+                // Route res frames to pendingRequests
+                if (frame.type === 'res' && frame.id) {
+                    const pending = pendingRequests.get(frame.id);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        pendingRequests.delete(frame.id);
+                        pending.resolve({
+                            ok: frame.ok === true,
+                            payload: frame.payload,
+                            error: frame.error,
+                        });
+                    }
+                    return;
+                }
+                // Route event frames to event queue (capped to prevent leaks).
+                // Never drop final/error events — they're required to terminate the stream loop.
+                if (frame.type === 'event') {
+                    if (eventQueue.length >= MAX_EVENT_QUEUE) {
+                        let dropIdx = -1;
+                        for (let i = 0; i < eventQueue.length; i++) {
+                            if (!isStreamEndEvent(eventQueue[i])) {
+                                dropIdx = i;
+                                break;
+                            }
+                        }
+                        if (dropIdx >= 0) {
+                            eventQueue.splice(dropIdx, 1);
+                        }
+                    }
+                    eventQueue.push(frame);
+                    wakeUp?.();
+                }
+            }
+            catch {
+                // skip malformed
+            }
+        };
+        ws.on('message', persistHandler);
+        const onClose = () => {
+            streamDone = true;
+            // Reject all pending requests
+            for (const [, p] of pendingRequests) {
+                clearTimeout(p.timer);
+                p.reject(new Error('WebSocket closed'));
+            }
+            pendingRequests.clear();
+            wakeUp?.();
+        };
+        ws.on('close', onClose);
+        const onAbort = () => {
+            // Best-effort abort via ws send
+            try {
+                ws.send(JSON.stringify({ type: 'req', id: `abort-${Date.now()}`, method: 'chat.abort', params: { sessionKey: sessionId } }));
+            }
+            catch { /* ignore */ }
+            ws.close();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            const baseSessionKey = !isOneshot && sessionId ? sessionId : `wm-${randomUUID().slice(0, 8)}`;
+            const sessionKey = this.agentId ? toAgentSessionKey(baseSessionKey, this.agentId) : baseSessionKey;
+            const message = task.systemPrompt
+                ? `${task.systemPrompt}\n\n---\n\n${task.input}`
+                : task.input;
+            // Send chat.send via pendingRequests map (not the generic sendRequest)
+            const chatSendResult = await this.sendRequestViaMap(ws, pendingRequests, 'chat.send', {
+                sessionKey,
+                message,
+                idempotencyKey: `wm-${randomUUID()}`,
+            });
+            if (!chatSendResult.ok) {
+                const errMsg = typeof chatSendResult.error === 'string'
+                    ? chatSendResult.error
+                    : JSON.stringify(chatSendResult.error);
+                yield { type: 'error', message: `chat.send failed: ${errMsg}` };
+                return;
+            }
+            const ack = chatSendResult.payload;
+            const runId = ack?.runId;
+            sessionId = sessionKey;
+            // Stream events from the persistent handler's queue
+            let resultText = '';
+            let msgIdx = 0;
+            while (!streamDone) {
+                if (signal?.aborted)
+                    break;
+                while (msgIdx < eventQueue.length) {
+                    const frame = eventQueue[msgIdx++];
+                    if (frame.event === 'chat') {
+                        const payload = frame.payload;
+                        if (!payload)
+                            continue;
+                        if (runId && payload.runId && payload.runId !== runId)
+                            continue;
+                        const state = typeof payload.state === 'string' ? payload.state : undefined;
+                        if (state === 'delta') {
+                            const text = extractTextFromPayload(payload);
+                            if (text) {
+                                resultText += text;
+                                yield { type: 'delta', content: text };
+                            }
+                        }
+                        else if (state === 'final' && !finalized) {
+                            finalized = true;
+                            const text = extractTextFromPayload(payload);
+                            if (text)
+                                resultText += text;
+                            streamDone = true;
+                        }
+                        else if (state === 'error' && !finalized) {
+                            finalized = true;
+                            const errMsg = typeof payload.errorMessage === 'string'
+                                ? payload.errorMessage
+                                : 'chat error';
+                            yield { type: 'error', message: errMsg };
+                            return;
+                        }
+                    }
+                    if (frame.event === 'agent') {
+                        const payload = frame.payload;
+                        if (!payload)
+                            continue;
+                        if (runId && payload.runId && payload.runId !== runId)
+                            continue;
+                        const stream = typeof payload.stream === 'string' ? payload.stream : '';
+                        const data = (payload.data ?? {});
+                        if (stream === 'assistant') {
+                            const delta = extractAgentAssistantText(data);
+                            if (delta) {
+                                resultText += delta;
+                                yield { type: 'delta', content: delta };
+                            }
+                        }
+                        else if (stream === 'tool' && typeof data.name === 'string') {
+                            // Observability only — Gateway executes tools via MCP
+                            const argsStr = typeof data.arguments === 'string'
+                                ? data.arguments
+                                : JSON.stringify(data.arguments ?? {});
+                            yield { type: 'thinking', content: `[工具] ${data.name}(${argsStr.slice(0, 200)})` };
+                        }
+                        else if (stream === 'result') {
+                            const resultTxt = extractAgentAssistantText(data);
+                            if (resultTxt) {
+                                resultText += resultTxt;
+                                yield { type: 'delta', content: resultTxt };
+                            }
+                        }
+                        else if (stream === 'error' && !finalized) {
+                            finalized = true;
+                            const errMsg = typeof data.error === 'string'
+                                ? data.error
+                                : typeof data.message === 'string'
+                                    ? data.message
+                                    : 'agent error';
+                            yield { type: 'error', message: errMsg };
+                            return;
+                        }
+                        else if (stream === 'lifecycle') {
+                            const phase = data.phase;
+                            if (phase === 'end' && !finalized) {
+                                finalized = true;
+                                streamDone = true;
+                            }
+                            else if (phase === 'error' && !finalized) {
+                                finalized = true;
+                                const errMsg = (typeof data.error === 'string' ? data.error : undefined)
+                                    ?? (typeof data.message === 'string' ? data.message : undefined)
+                                    ?? 'agent lifecycle error';
+                                yield { type: 'error', message: errMsg };
+                                return;
+                            }
+                        }
+                    }
+                }
+                if (ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
+                    break;
+                }
+                if (!streamDone) {
+                    await new Promise((resolve) => {
+                        wakeUp = resolve;
+                    });
+                    wakeUp = null;
+                }
+            }
+            yield {
+                type: 'result',
+                content: resultText.trim() || (ack?.status === 'started' ? '任务已提交，等待执行...' : ''),
+                sessionId: isOneshot ? undefined : sessionId,
+            };
+        }
+        catch (err) {
+            yield { type: 'error', message: err instanceof Error ? err.message : String(err) };
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            ws.off('message', persistHandler);
+            ws.off('close', onClose);
+            ws.close();
+        }
+    }
+    // ── discoverSkills ──
+    async discoverSkills(context) {
+        const result = [];
+        const seen = new Set();
+        const layers = [];
+        if (context.workDir) {
+            layers.push({ dir: join(context.workDir, 'skills'), source: 'project' });
+            layers.push({ dir: join(context.workDir, '.agents', 'skills'), source: 'project' });
+        }
+        layers.push({ dir: join(homedir(), '.agents', 'skills'), source: 'user' });
+        layers.push({ dir: join(OPENCLAW_DIR, 'skills'), source: 'bundled' });
+        for (const layer of layers) {
+            if (!existsSync(layer.dir))
+                continue;
+            try {
+                const skills = this.scanSkillDir(layer.dir, layer.source);
+                for (const skill of skills) {
+                    if (!seen.has(skill.name)) {
+                        seen.add(skill.name);
+                        result.push(skill);
+                    }
+                }
+            }
+            catch { /* silently skip */ }
+        }
+        return result;
+    }
+    scanSkillDir(dir, source) {
+        const skills = [];
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillMdPath = join(dir, entry.name, 'SKILL.md');
+                if (!existsSync(skillMdPath))
+                    continue;
+                const parsed = parseSkillMd(skillMdPath);
+                if (parsed) {
+                    skills.push({ ...parsed, source });
+                }
+            }
+        }
+        catch { /* silently skip */ }
+        return skills;
+    }
+    // ── authenticated WebSocket connect ──
+    authenticatedConnect(url, host, signal) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(url, {
+                headers: { Origin: `http://${host}` },
+            });
+            let handshakeDone = false;
+            const onAbort = () => {
+                ws.close();
+                if (!handshakeDone)
+                    reject(new Error('Aborted'));
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const cleanup = () => {
+                handshakeDone = true;
+                signal?.removeEventListener('abort', onAbort);
+                ws.off('message', onMessage);
+            };
+            const onMessage = (data) => {
+                try {
+                    const frame = JSON.parse(data.toString());
+                    if (frame.event === 'connect.challenge') {
+                        const connectId = `connect-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                        const role = 'operator';
+                        const scopes = ['operator.admin', 'operator.write', 'operator.read'];
+                        const connectParams = {
+                            minProtocol: PROTOCOL_VERSION,
+                            maxProtocol: PROTOCOL_VERSION,
+                            client: {
+                                // 'gateway-client' + mode:'backend' = loopback backend 客户端（官方支持，无需 device identity）。
+                                // 服务端 workstation 使用 'openclaw-control-ui' + mode:'webchat'，两者 client.id 不同是因为
+                                // daemon 走本地 loopback（同机部署），server 走容器远程连接。
+                                id: 'gateway-client',
+                                displayName: 'WinMatrix Agent',
+                                version: '1.0.0',
+                                platform: process.platform,
+                                mode: 'backend',
+                            },
+                            role,
+                            scopes,
+                        };
+                        if (this.token) {
+                            connectParams.auth = { token: this.token };
+                        }
+                        ws.send(JSON.stringify({ type: 'req', id: connectId, method: 'connect', params: connectParams }));
+                        return;
+                    }
+                    if (frame.type === 'res' && frame.id?.startsWith('connect-')) {
+                        if (frame.ok) {
+                            cleanup();
+                            resolve(ws);
+                        }
+                        else {
+                            cleanup();
+                            const errDetail = typeof frame.error === 'string' ? frame.error : JSON.stringify(frame.error);
+                            reject(new Error(`Gateway connect rejected: ${errDetail}`));
+                        }
+                    }
+                }
+                catch {
+                    // skip malformed frames during handshake
+                }
+            };
+            ws.on('message', onMessage);
+            ws.on('error', (err) => {
+                cleanup();
+                reject(new Error(`OpenClaw Gateway not reachable at ${url}: ${err.message}`));
+            });
+            ws.on('close', () => {
+                if (!handshakeDone) {
+                    cleanup();
+                    reject(new Error('WebSocket closed before handshake completed'));
+                }
+            });
+            if (signal?.aborted) {
+                ws.close();
+                reject(new Error('Aborted'));
+            }
+        });
+    }
+    // ── RPC helpers ──
+    /**
+     * Generic sendRequest — temporary onMessage handler pattern.
+     * Used by healthCheck/listSessions/getSession (short-lived connections).
+     */
+    sendRequest(ws, method, params) {
+        return new Promise((resolve, reject) => {
+            const id = `${method}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            let resolved = false;
+            const timer = setTimeout(() => {
+                if (resolved)
+                    return;
+                resolved = true;
+                ws.off('message', onMessage);
+                reject(new Error(`OpenClaw request timeout: ${method}`));
+            }, 30_000);
+            const onMessage = (data) => {
+                try {
+                    const frame = JSON.parse(data.toString());
+                    if (frame.type === 'res' && frame.id === id) {
+                        if (resolved)
+                            return;
+                        resolved = true;
+                        clearTimeout(timer);
+                        ws.off('message', onMessage);
+                        resolve({
+                            ok: frame.ok === true,
+                            payload: frame.payload,
+                            error: frame.error,
+                        });
+                    }
+                }
+                catch {
+                    // skip malformed frames
+                }
+            };
+            ws.on('message', onMessage);
+            ws.send(JSON.stringify({ type: 'req', id, method, params }));
+        });
+    }
+    /**
+     * Send a request using a pendingRequests map (persistent handler multiplexing).
+     * Used by execute() to multiplex req/res with event streaming on the same ws.
+     */
+    sendRequestViaMap(ws, pendingRequests, method, params) {
+        return new Promise((resolve, reject) => {
+            const id = `${method}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const timer = setTimeout(() => {
+                pendingRequests.delete(id);
+                reject(new Error(`OpenClaw request timeout: ${method}`));
+            }, 30_000);
+            pendingRequests.set(id, { resolve, reject, timer });
+            ws.send(JSON.stringify({ type: 'req', id, method, params }));
+        });
+    }
+    // ── healthCheck ──
+    async healthCheck() {
+        try {
+            const ws = await this.authenticatedConnect(this.gatewayUrl, this.gatewayHost);
+            const result = await this.sendRequest(ws, 'health', {});
+            ws.close();
+            if (result.ok) {
+                const version = typeof result.payload?.version === 'string' ? result.payload.version : undefined;
+                return { available: true, version };
+            }
+            return { available: true };
+        }
+        catch (err) {
+            return { available: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    // ── listSessions ──
+    async listSessions(options) {
+        try {
+            const ws = await this.authenticatedConnect(this.gatewayUrl, this.gatewayHost);
+            const result = await this.sendRequest(ws, 'sessions.list', {
+                dir: options.dir,
+                limit: options.limit ?? 50,
+            });
+            ws.close();
+            if (!result.ok && result.error) {
+                return { sessions: [], error: typeof result.error === 'string' ? result.error : JSON.stringify(result.error) };
+            }
+            const data = result.payload;
+            const raw = data?.sessions ?? [];
+            const sessions = raw.map((s) => ({
+                id: String(s.id ?? s.session_id ?? s.sessionKey ?? ''),
+                cwd: typeof s.cwd === 'string' ? s.cwd : undefined,
+                summary: typeof s.summary === 'string' ? s.summary : undefined,
+                createdAt: typeof s.created_at === 'string' ? s.created_at : undefined,
+                lastActivityAt: typeof s.last_activity_at === 'string' ? s.last_activity_at : undefined,
+                messageCount: typeof s.message_count === 'number' ? s.message_count : undefined,
+                status: typeof s.status === 'string' ? s.status : undefined,
+            }));
+            return { sessions };
+        }
+        catch (err) {
+            return { sessions: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    // ── getSession ──
+    async getSession(sessionId, options = {}) {
+        try {
+            const ws = await this.authenticatedConnect(this.gatewayUrl, this.gatewayHost);
+            const result = await this.sendRequest(ws, 'sessions.preview', {
+                sessionKey: sessionId,
+                messageLimit: options.messageLimit ?? 100,
+                includeRaw: options.includeRawMessages === true,
+            });
+            ws.close();
+            if (!result.ok && result.error) {
+                return {
+                    session: { id: sessionId },
+                    messageCount: 0,
+                    truncated: false,
+                    userPrompts: [],
+                    assistantText: '',
+                    lastAssistantText: '',
+                    error: typeof result.error === 'string' ? result.error : JSON.stringify(result.error),
+                };
+            }
+            const data = result.payload;
+            const messages = data?.messages ?? [];
+            let assistantText = '';
+            let lastAssistantText = '';
+            const userPrompts = [];
+            for (const msg of messages) {
+                if (msg.role === 'user' && msg.content) {
+                    userPrompts.push(msg.content);
+                }
+                else if (msg.role === 'assistant' && msg.content) {
+                    assistantText += msg.content + '\n';
+                    lastAssistantText = msg.content;
+                }
+            }
+            return {
+                session: {
+                    id: sessionId,
+                    ...(data?.session ?? {}),
+                },
+                messageCount: messages.length,
+                truncated: messages.length >= (options.messageLimit ?? 100),
+                userPrompts,
+                assistantText: assistantText.trim(),
+                lastAssistantText,
+                rawMessages: options.includeRawMessages ? messages : undefined,
+                rawMessagesIncluded: options.includeRawMessages === true,
+            };
+        }
+        catch (err) {
+            return {
+                session: { id: sessionId },
+                messageCount: 0,
+                truncated: false,
+                userPrompts: [],
+                assistantText: '',
+                lastAssistantText: '',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}
+//# sourceMappingURL=OpenClawAdapter.js.map