@okclaw-build/cli 1.0.0-beta.6 → 1.0.0-beta.60

package/dist/bridge/daemon/openclaw-chat-runtime.js

@@ -0,0 +1,1222 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { readFile as fsReadFile, realpath as fsRealpath, stat as fsStat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, isAbsolute, join as joinPath, resolve as resolvePath, sep as pathSep } from 'node:path';
+import { bridgeEventId } from './event-id.js';
+import { OpenClawGatewayClient, OpenClawGatewayError, } from './openclaw-gateway-client.js';
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+const MAX_TOTAL_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+const MAX_ARTIFACT_BYTES = 5 * 1024 * 1024;
+const FILE_REF_DOWNLOAD_ATTEMPTS = 2;
+const MANAGED_MEDIA_PATH_PREFIX = '/api/chat/media/outgoing/';
+const MAX_OUTBOUND_FILES = 5;
+const FILE_EXT_MIME = {
+    md: 'text/markdown',
+    markdown: 'text/markdown',
+    txt: 'text/plain',
+    csv: 'text/csv',
+    json: 'application/json',
+    pdf: 'application/pdf',
+    zip: 'application/zip',
+    html: 'text/html',
+    xml: 'application/xml',
+    yaml: 'application/yaml',
+    yml: 'application/yaml',
+    log: 'text/plain',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+export class OpenClawChatRuntime {
+    config;
+    options;
+    gateway;
+    startPromise;
+    gatewayConnected = false;
+    gatewayVersion = 'unknown';
+    lastGatewayErrorCode;
+    byRequestId = new Map();
+    requestIdByRunId = new Map();
+    publishedArtifactKeys = new Set();
+    workspaceRootsCache;
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+    }
+    async start() {
+        if (this.gatewayConnected) {
+            return;
+        }
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        this.startPromise = this.connectGateway();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            if (!this.gatewayConnected) {
+                this.startPromise = undefined;
+            }
+        }
+    }
+    stop() {
+        this.gateway?.close();
+        this.gateway = undefined;
+        this.gatewayConnected = false;
+        this.startPromise = undefined;
+    }
+    getRuntimeInfo() {
+        return {
+            gatewayConnected: this.gatewayConnected,
+            gatewayVersion: this.gatewayVersion,
+            ...(this.lastGatewayErrorCode ? { lastGatewayErrorCode: this.lastGatewayErrorCode } : {}),
+        };
+    }
+    async handleChatSend(request, sink) {
+        const requestId = request.requestId;
+        const params = request.params;
+        const sessionKey = textParam(params, 'sessionKey');
+        if (!sessionKey) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_CHAT_SESSION_REQUIRED', 'chat.send sessionKey is required'));
+            return;
+        }
+        const openclawSessionKey = textParam(params, 'openclawSessionKey');
+        if (!openclawSessionKey) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_CHAT_OPENCLAW_SESSION_REQUIRED', 'chat.send openclawSessionKey is required'));
+            return;
+        }
+        const conversationId = longParam(params, 'conversationId');
+        if (conversationId === undefined || conversationId <= 0) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_CHAT_CONVERSATION_REQUIRED', 'chat.send conversationId is required'));
+            return;
+        }
+        const message = textParam(params, 'message') ?? textParam(params, 'text');
+        if (!message || message.trim().length === 0) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_CHAT_MESSAGE_REQUIRED', 'chat.send message is required'));
+            return;
+        }
+        if (hasNonEmptyList(params.fileIds) || hasNonEmptyList(params.attachments)) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_ATTACHMENTS_UNSUPPORTED', 'fileIds and raw attachments are not supported by this bridge runtime'));
+            return;
+        }
+        let attachments;
+        try {
+            attachments = hasNonEmptyList(params.fileRefs) ? await this.buildGatewayAttachments(params.fileRefs) : [];
+        }
+        catch (err) {
+            const error = normalizeError(err, 'E_BRIDGE_ATTACHMENT_DOWNLOAD_FAILED');
+            sink.sendRpcResult(rpcFailure(requestId, error.code, error.message));
+            return;
+        }
+        try {
+            await this.start();
+        }
+        catch (err) {
+            const error = normalizeError(err, 'E_BRIDGE_GATEWAY_CONNECT_FAILED');
+            sink.sendRpcResult(rpcFailure(requestId, error.code, error.message));
+            return;
+        }
+        const gateway = this.gateway;
+        if (!gateway) {
+            sink.sendRpcResult(rpcFailure(requestId, 'E_BRIDGE_GATEWAY_CONNECT_FAILED', 'OpenClaw Gateway is not connected'));
+            return;
+        }
+        const active = {
+            requestId,
+            runId: requestId,
+            sessionKey,
+            openclawSessionKey,
+            conversationId,
+            customerId: longParam(params, 'customerId'),
+            shrimpId: longParam(params, 'shrimpId'),
+            sink,
+            acked: false,
+            finalSeen: false,
+        };
+        this.registerActive(active);
+        try {
+            const response = await gateway.request('chat.send', {
+                sessionKey: openclawSessionKey,
+                message,
+                attachments,
+                idempotencyKey: requestId,
+            }, request.deadlineMs ?? this.config.gateway.requestTimeoutMs);
+            const runId = textParam(response, 'runId') ?? requestId;
+            const gatewayStatus = textParam(response, 'status') ?? 'started';
+            this.requestIdByRunId.delete(active.runId);
+            active.runId = runId;
+            active.acked = true;
+            this.requestIdByRunId.set(runId, requestId);
+            sink.sendRpcResult({
+                type: 'rpc_result',
+                eventId: bridgeEventId(requestId, 'ack'),
+                requestId,
+                ok: true,
+                result: {
+                    runId,
+                    status: 'accepted',
+                    gatewayStatus,
+                    sessionKey,
+                    openclawSessionKey,
+                    conversationId,
+                },
+            });
+            if (gatewayStatus === 'ok') {
+                this.emitFailure(active, {
+                    errorCode: 'E_BRIDGE_GATEWAY_FINAL_UNAVAILABLE',
+                    errorMessage: 'Gateway chat already completed but final message is unavailable',
+                    gatewayStatus,
+                });
+                return;
+            }
+            if (gatewayStatus === 'timeout') {
+                this.emitFailure(active, {
+                    errorCode: 'E_BRIDGE_GATEWAY_CHAT_ABORTED',
+                    errorMessage: 'Gateway chat ended before a final message was available',
+                    gatewayStatus,
+                    stopReason: textParam(response, 'stopReason'),
+                });
+            }
+        }
+        catch (err) {
+            this.unregisterActive(active);
+            const error = normalizeError(err, 'E_BRIDGE_GATEWAY_RPC_FAILED');
+            this.lastGatewayErrorCode = error.code;
+            sink.sendRpcResult(rpcFailure(requestId, error.code, error.message));
+        }
+    }
+    async connectGateway() {
+        const token = this.resolveGatewayToken();
+        if (!token) {
+            this.lastGatewayErrorCode = 'E_BRIDGE_GATEWAY_AUTH_MISSING';
+            throw new OpenClawGatewayError('E_BRIDGE_GATEWAY_AUTH_MISSING', 'Gateway token is missing');
+        }
+        const gateway = new OpenClawGatewayClient({
+            url: this.config.gateway.url,
+            token,
+            installedVersion: this.options.installedVersion,
+            nonce: this.options.nonce,
+            webSocketFactory: this.options.gatewayWebSocketFactory,
+            timers: this.options.timers,
+            connectTimeoutMs: this.config.gateway.connectTimeoutMs,
+            requestTimeoutMs: this.config.gateway.requestTimeoutMs,
+        });
+        gateway.onEvent((event) => this.handleGatewayEvent(event));
+        gateway.onClose(() => this.handleGatewayClose());
+        this.gateway = gateway;
+        try {
+            const hello = await gateway.connect();
+            if (!hello.methods.includes('chat.send')) {
+                this.lastGatewayErrorCode = 'E_BRIDGE_GATEWAY_METHOD_UNSUPPORTED';
+                throw new OpenClawGatewayError('E_BRIDGE_GATEWAY_METHOD_UNSUPPORTED', 'OpenClaw Gateway does not support chat.send');
+            }
+            if (hello.events !== undefined && !hello.events.includes('chat')) {
+                this.lastGatewayErrorCode = 'E_BRIDGE_GATEWAY_METHOD_UNSUPPORTED';
+                throw new OpenClawGatewayError('E_BRIDGE_GATEWAY_METHOD_UNSUPPORTED', 'OpenClaw Gateway does not advertise chat event');
+            }
+            this.gatewayConnected = true;
+            this.gatewayVersion = hello.serverVersion;
+            this.lastGatewayErrorCode = undefined;
+        }
+        catch (err) {
+            gateway.close();
+            this.gatewayConnected = false;
+            this.gateway = undefined;
+            const error = normalizeError(err, 'E_BRIDGE_GATEWAY_CONNECT_REJECTED');
+            this.lastGatewayErrorCode = error.code;
+            throw new OpenClawGatewayError(error.code, error.message);
+        }
+    }
+    async buildGatewayAttachments(value) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return [];
+        }
+        const attachments = [];
+        let totalBytes = 0;
+        for (const item of value) {
+            const fileRef = parseFileRef(item);
+            if (!fileRef) {
+                throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_INVALID', 'fileRef is invalid');
+            }
+            const bytes = await this.downloadFileRef(fileRef, MAX_TOTAL_ATTACHMENT_BYTES - totalBytes);
+            if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
+                throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRef exceeds 5MiB limit');
+            }
+            totalBytes += bytes.byteLength;
+            if (totalBytes > MAX_TOTAL_ATTACHMENT_BYTES) {
+                throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRefs exceed 10MiB total limit');
+            }
+            if (fileRef.sizeBytes !== undefined && fileRef.sizeBytes !== bytes.byteLength) {
+                throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_INVALID', 'fileRef size mismatch');
+            }
+            if (fileRef.sha256 && sha256Hex(bytes) !== fileRef.sha256.toLowerCase()) {
+                throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_INVALID', 'fileRef sha256 mismatch');
+            }
+            attachments.push({
+                type: fileRef.mimeType.startsWith('image/') ? 'image' : 'file',
+                fileName: fileRef.fileName,
+                mimeType: fileRef.mimeType,
+                content: Buffer.from(bytes).toString('base64'),
+            });
+        }
+        return attachments;
+    }
+    async downloadFileRef(fileRef, maxBytes) {
+        if (maxBytes <= 0) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRefs exceed 10MiB total limit');
+        }
+        const fetchImpl = this.options.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_DOWNLOAD_FAILED', 'fetch is not available');
+        }
+        let response;
+        let lastDownloadError;
+        for (let attempt = 1; attempt <= FILE_REF_DOWNLOAD_ATTEMPTS; attempt += 1) {
+            try {
+                response = await fetchWithTimeout(fetchImpl, fileRef.downloadUrl, undefined, this.config.gateway.requestTimeoutMs, 'E_BRIDGE_ATTACHMENT_DOWNLOAD_TIMEOUT', 'fileRef download timed out');
+                break;
+            }
+            catch (err) {
+                if (err instanceof OpenClawGatewayError) {
+                    throw err;
+                }
+                lastDownloadError = err;
+            }
+        }
+        if (!response) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_DOWNLOAD_FAILED', errorMessage(lastDownloadError));
+        }
+        if (!response.ok) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_DOWNLOAD_FAILED', `fileRef download failed status=${response.status}`);
+        }
+        const contentLength = parseContentLength(response.headers?.get('content-length'));
+        if (contentLength !== undefined && contentLength > Math.min(MAX_ATTACHMENT_BYTES, maxBytes)) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRef exceeds size limit');
+        }
+        return readResponseBytes(response, Math.min(MAX_ATTACHMENT_BYTES, maxBytes));
+    }
+    handleGatewayEvent(frame) {
+        if (frame.event === 'session.message') {
+            return;
+        }
+        if (frame.event !== 'chat') {
+            return;
+        }
+        const payload = frame.payload;
+        const runId = textParam(payload, 'runId');
+        if (!runId) {
+            return;
+        }
+        const active = this.activeByRunId(runId);
+        if (!active) {
+            console.warn(`[okclaw-bridge] ignored unmatched Gateway chat event runId=${runId}`);
+            return;
+        }
+        const state = textParam(payload, 'state');
+        if (state === 'delta') {
+            this.emitDelta(active, payload);
+            return;
+        }
+        if (state === 'final') {
+            this.emitFinal(active, payload);
+            return;
+        }
+        if (state === 'error') {
+            this.emitFailure(active, {
+                errorCode: 'E_BRIDGE_GATEWAY_CHAT_FAILED',
+                errorMessage: textParam(payload, 'errorMessage') ?? 'Gateway chat failed',
+                gatewayErrorKind: textParam(payload, 'errorKind'),
+                stopReason: textParam(payload, 'stopReason'),
+            });
+            return;
+        }
+        if (state === 'aborted') {
+            this.emitFailure(active, {
+                errorCode: 'E_BRIDGE_GATEWAY_CHAT_ABORTED',
+                errorMessage: 'Gateway chat aborted',
+                stopReason: textParam(payload, 'stopReason'),
+            });
+        }
+    }
+    handleGatewayClose() {
+        this.gatewayConnected = false;
+        this.gateway = undefined;
+        this.startPromise = undefined;
+        this.lastGatewayErrorCode = 'E_BRIDGE_GATEWAY_CONNECT_FAILED';
+        for (const active of [...this.byRequestId.values()]) {
+            if (active.acked && !active.finalSeen) {
+                this.emitFailure(active, {
+                    errorCode: 'E_BRIDGE_GATEWAY_CHAT_FAILED',
+                    errorMessage: 'OpenClaw Gateway connection closed before final message',
+                });
+            }
+            else {
+                this.unregisterActive(active);
+            }
+        }
+    }
+    emitDelta(active, payload) {
+        const deltaText = textParam(payload, 'deltaText');
+        if (deltaText === undefined) {
+            return;
+        }
+        const seq = longParam(payload, 'seq') ?? 1;
+        active.sink.sendEvent({
+            type: 'event',
+            eventId: bridgeEventId(active.requestId, `delta_${seq}`),
+            requestId: active.requestId,
+            eventType: 'chat.delta',
+            payload: {
+                ...basePayload(active),
+                deltaText,
+                replace: payload.replace === true,
+            },
+        });
+    }
+    emitFinal(active, payload) {
+        if (active.finalSeen) {
+            return;
+        }
+        active.finalSeen = true;
+        const message = normalizeAssistantMessage(payload.message);
+        if (!message) {
+            this.emitFailure(active, {
+                errorCode: 'E_BRIDGE_GATEWAY_EMPTY_FINAL',
+                errorMessage: 'Gateway final message is empty',
+            });
+            return;
+        }
+        active.sink.sendEvent({
+            type: 'event',
+            eventId: bridgeEventId(active.requestId, 'final'),
+            requestId: active.requestId,
+            eventType: 'session.message',
+            payload: {
+                ...basePayload(active),
+                message,
+            },
+        });
+        void this.publishOutboundMedia(active, payload.message).catch((err) => {
+            console.warn(`[okclaw-bridge] outbound media publish scan failed requestId=${active.requestId} runId=${active.runId} message=${errorMessage(err)}`);
+        });
+        this.unregisterActive(active);
+    }
+    // OpenClaw 把 agent 生成的媒体持久化进一条"gateway-injected"transcript 消息，
+    // 该消息不带 runId，因此 artifacts.list {runId} 永远过滤不到它（见 OpenClaw
+    // artifacts.test.ts "does not return untagged session artifacts for scoped runId queries"）。
+    // 这里改为直接从 webchat final 消息内容里抽取媒体块（assistant 本轮产出、天然 run+role 限定，
+    // 不含历史/入站用户图片），data URL 本地解码、托管 /api/chat/media/outgoing/ URL 用 gateway
+    // 共享密钥 token 经 HTTP 取字节，再走 outbound grant → COS → artifact.published。
+    async publishOutboundMedia(active, message) {
+        // 图片/音频:webchat content block 或 OpenClaw reply payload 的 mediaUrl(s)。
+        // 文件:优先支持 reply payload 的 path/filePath/mediaUrls 本地路径;final 文本里的 markdown/MEDIA
+        // 本地路径只作为兼容兜底。所有本地路径都在工作区沙箱内 realpath 后再读字节。
+        const blocks = extractOutboundMediaBlocks(message);
+        const fileRefs = await this.extractOutboundFileRefs(message);
+        for (const media of [...blocks, ...fileRefs]) {
+            const dedupeKey = `${active.runId}:${media.artifactId}`;
+            if (this.publishedArtifactKeys.has(dedupeKey)) {
+                continue;
+            }
+            this.publishedArtifactKeys.add(dedupeKey);
+            await this.publishOneOutboundMedia(active, media);
+        }
+    }
+    async publishOneOutboundMedia(active, media) {
+        let bytes;
+        let mimeType;
+        try {
+            const resolved = await this.resolveOutboundMediaBytes(media);
+            bytes = resolved.bytes;
+            mimeType = normalizeMimeType(resolved.mimeType ?? media.mimeType);
+        }
+        catch (err) {
+            const reason = err instanceof OpenClawGatewayError && err.code === 'E_BRIDGE_ARTIFACT_FORBIDDEN_URL'
+                ? 'unsupported_download_mode'
+                : 'download_failed';
+            this.emitOutboundUnsupported(active, media, reason, errorMessage(err));
+            return;
+        }
+        if (bytes.byteLength === 0) {
+            this.emitOutboundUnsupported(active, media, 'empty_artifact');
+            return;
+        }
+        if (bytes.byteLength > MAX_ARTIFACT_BYTES) {
+            this.emitOutboundUnsupported(active, media, 'artifact_too_large');
+            return;
+        }
+        const sizeBytes = bytes.byteLength;
+        const fileName = media.fileName;
+        let grant;
+        try {
+            grant = await active.sink.sendOpsRequest({
+                method: 'oneberry.files.createOutboundUpload',
+                deadlineMs: this.config.gateway.requestTimeoutMs,
+                params: {
+                    requestId: active.requestId,
+                    runId: active.runId,
+                    sessionKey: active.sessionKey,
+                    conversationId: active.conversationId,
+                    ...(active.customerId !== undefined ? { customerId: active.customerId } : {}),
+                    ...(active.shrimpId !== undefined ? { shrimpId: active.shrimpId } : {}),
+                    artifactId: media.artifactId,
+                    fileName,
+                    mimeType,
+                    sizeBytes,
+                },
+            });
+        }
+        catch (err) {
+            this.emitOutboundUnsupported(active, media, 'upload_grant_failed', errorMessage(err));
+            return;
+        }
+        const uploadUrl = textParam(grant, 'uploadUrl');
+        if (!uploadUrl) {
+            this.emitOutboundUnsupported(active, media, 'upload_grant_invalid');
+            return;
+        }
+        try {
+            await this.uploadArtifact(uploadUrl, bytes, mimeType);
+        }
+        catch (err) {
+            this.emitOutboundUnsupported(active, media, 'upload_failed', errorMessage(err));
+            return;
+        }
+        active.sink.sendEvent({
+            type: 'event',
+            eventId: bridgeEventId(active.requestId, `artifact_published_${media.artifactId}`),
+            requestId: active.requestId,
+            eventType: 'artifact.published',
+            payload: {
+                ...basePayload(active),
+                fileId: longParam(grant, 'fileId'),
+                artifactId: media.artifactId,
+                fileName,
+                mimeType,
+                sizeBytes,
+                ...(textParam(grant, 'objectKey') ? { objectKey: textParam(grant, 'objectKey') } : {}),
+                source: 'openclaw.webchat.media',
+            },
+        });
+    }
+    async resolveOutboundMediaBytes(media) {
+        if (media.source.kind === 'data') {
+            return { bytes: Buffer.from(media.source.base64, 'base64'), mimeType: media.mimeType };
+        }
+        if (media.source.kind === 'localfile') {
+            return this.readOutboundLocalFile(media.source.path, media.mimeType);
+        }
+        const fetchImpl = this.options.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_DOWNLOAD_FAILED', 'fetch is not available');
+        }
+        const url = this.resolveGatewayHttpUrl(media.source.url);
+        const token = this.resolveGatewayToken();
+        const response = await fetchWithTimeout(fetchImpl, url, { headers: token ? { authorization: `Bearer ${token}` } : {} }, this.config.gateway.requestTimeoutMs, 'E_BRIDGE_ARTIFACT_DOWNLOAD_TIMEOUT', 'artifact download timed out');
+        if (!response.ok) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_DOWNLOAD_FAILED', `artifact download failed status=${response.status}`);
+        }
+        const bytes = await readResponseBytes(response, MAX_ARTIFACT_BYTES);
+        const responseMime = response.headers.get('content-type') ?? undefined;
+        return { bytes, mimeType: media.mimeType ?? responseMime };
+    }
+    // 仅允许回源到 gateway 自身的托管媒体路径，杜绝 bridge 被诱导去 fetch 任意外链（SSRF）。
+    resolveGatewayHttpUrl(raw) {
+        const base = new URL(this.config.gateway.url);
+        const httpProtocol = base.protocol === 'wss:' ? 'https:' : base.protocol === 'ws:' ? 'http:' : base.protocol;
+        const origin = `${httpProtocol}//${base.host}`;
+        let parsed;
+        try {
+            parsed = new URL(raw, origin);
+        }
+        catch {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_FORBIDDEN_URL', 'artifact url is invalid');
+        }
+        if (parsed.host !== base.host || !parsed.pathname.startsWith(MANAGED_MEDIA_PATH_PREFIX)) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_FORBIDDEN_URL', 'artifact url is not an allowed managed media path');
+        }
+        parsed.protocol = httpProtocol;
+        return parsed.toString();
+    }
+    resolveGatewayToken() {
+        return this.options.tokenProvider?.() ?? readGatewayToken(this.config);
+    }
+    // 从 final 文本里解析指向工作区的文件链接/路径,realpath 后必须落在工作区沙箱内才采纳。
+    async extractOutboundFileRefs(message) {
+        const roots = await this.resolveWorkspaceRoots();
+        if (roots.length === 0) {
+            return [];
+        }
+        const candidates = [
+            ...extractStructuredLocalFileCandidates(message),
+            ...parseFileCandidatesFromText(collectMessageText(message)),
+        ];
+        const out = [];
+        const seen = new Set();
+        for (const candidate of candidates) {
+            if (out.length >= MAX_OUTBOUND_FILES) {
+                break;
+            }
+            let real;
+            try {
+                const abs = isAbsolute(candidate) ? candidate : resolvePath(roots[0], candidate);
+                real = await fsRealpath(abs);
+            }
+            catch {
+                continue;
+            }
+            if (!isInsideRoots(real, roots) || seen.has(real)) {
+                continue;
+            }
+            let isFile = false;
+            try {
+                isFile = (await fsStat(real)).isFile();
+            }
+            catch {
+                continue;
+            }
+            if (!isFile) {
+                continue;
+            }
+            seen.add(real);
+            const fileName = basename(real) || `file-${out.length + 1}`;
+            out.push({
+                artifactId: `file_${createHash('sha256').update(real).digest('hex').slice(0, 24)}`,
+                fileName,
+                mimeType: mimeForFileName(fileName),
+                source: { kind: 'localfile', path: real },
+            });
+        }
+        return out;
+    }
+    async readOutboundLocalFile(filePath, mimeType) {
+        const roots = await this.resolveWorkspaceRoots();
+        let real;
+        try {
+            real = await fsRealpath(filePath);
+        }
+        catch {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_DOWNLOAD_FAILED', 'outbound file not found');
+        }
+        // 读字节前再次沙箱校验(防 realpath 之后的 TOCTOU)。
+        if (roots.length === 0 || !isInsideRoots(real, roots)) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_FORBIDDEN_URL', 'outbound file is outside the workspace sandbox');
+        }
+        const stat = await fsStat(real);
+        if (!stat.isFile()) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_DOWNLOAD_FAILED', 'outbound file is not a regular file');
+        }
+        if (stat.size > MAX_ARTIFACT_BYTES) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_TOO_LARGE', 'outbound file exceeds size limit');
+        }
+        const buffer = await fsReadFile(real);
+        return { bytes: new Uint8Array(buffer), mimeType };
+    }
+    async resolveWorkspaceRoots() {
+        if (this.workspaceRootsCache) {
+            return this.workspaceRootsCache;
+        }
+        const roots = [];
+        const candidates = this.options.workspaceRoots && this.options.workspaceRoots.length > 0
+            ? this.options.workspaceRoots
+            : [readOpenClawWorkspaceDir(this.options.openclawConfigPath)];
+        for (const candidate of candidates) {
+            const trimmed = candidate?.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                roots.push(await fsRealpath(trimmed));
+            }
+            catch {
+                // 工作区不存在/不可读 → 该根不参与沙箱
+            }
+        }
+        this.workspaceRootsCache = roots;
+        return roots;
+    }
+    async uploadArtifact(uploadUrl, bytes, mimeType) {
+        const fetchImpl = this.options.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_UPLOAD_FAILED', 'fetch is not available');
+        }
+        const response = await fetchWithTimeout(fetchImpl, uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'content-type': mimeType,
+            },
+            body: new Blob([arrayBufferCopy(bytes)], { type: mimeType }),
+        }, this.config.gateway.requestTimeoutMs, 'E_BRIDGE_ARTIFACT_UPLOAD_TIMEOUT', 'artifact upload timed out');
+        if (!response.ok) {
+            throw new OpenClawGatewayError('E_BRIDGE_ARTIFACT_UPLOAD_FAILED', `artifact upload failed status=${response.status}`);
+        }
+    }
+    emitOutboundUnsupported(active, media, reason, message) {
+        active.sink.sendEvent({
+            type: 'event',
+            eventId: bridgeEventId(active.requestId, `artifact_unsupported_${media.artifactId}_${reason}`),
+            requestId: active.requestId,
+            eventType: 'artifact.unsupported',
+            payload: {
+                ...basePayload(active),
+                artifactId: media.artifactId,
+                fileName: media.fileName,
+                mimeType: media.mimeType,
+                reason,
+                ...(message ? { message } : {}),
+            },
+        });
+    }
+    emitFailure(active, failure) {
+        active.sink.sendEvent({
+            type: 'event',
+            eventId: bridgeEventId(active.requestId, 'failed'),
+            requestId: active.requestId,
+            eventType: 'message.failed',
+            payload: {
+                ...basePayload(active),
+                errorCode: failure.errorCode,
+                errorMessage: failure.errorMessage,
+                ...(failure.gatewayErrorKind ? { gatewayErrorKind: failure.gatewayErrorKind } : {}),
+                ...(failure.stopReason ? { stopReason: failure.stopReason } : {}),
+                ...(failure.gatewayStatus ? { gatewayStatus: failure.gatewayStatus } : {}),
+            },
+        });
+        this.unregisterActive(active);
+    }
+    registerActive(active) {
+        this.byRequestId.set(active.requestId, active);
+        this.requestIdByRunId.set(active.runId, active.requestId);
+    }
+    unregisterActive(active) {
+        this.byRequestId.delete(active.requestId);
+        this.requestIdByRunId.delete(active.runId);
+    }
+    activeByRunId(runId) {
+        const requestId = this.requestIdByRunId.get(runId);
+        return requestId ? this.byRequestId.get(requestId) : undefined;
+    }
+}
+function rpcFailure(requestId, errorCode, errorMessage) {
+    return {
+        type: 'rpc_result',
+        eventId: bridgeEventId(requestId, 'failed'),
+        requestId,
+        ok: false,
+        errorCode,
+        errorMessage,
+    };
+}
+function basePayload(active) {
+    return {
+        runId: active.runId,
+        sessionKey: active.sessionKey,
+        openclawSessionKey: active.openclawSessionKey,
+        conversationId: active.conversationId,
+        ...(active.customerId !== undefined ? { customerId: active.customerId } : {}),
+        ...(active.shrimpId !== undefined ? { shrimpId: active.shrimpId } : {}),
+    };
+}
+function readGatewayToken(config) {
+    const envName = config.gateway.authTokenEnv;
+    const envToken = envName ? process.env[envName]?.trim() : undefined;
+    if (envToken) {
+        return envToken;
+    }
+    const tokenFile = config.gateway.authTokenFile;
+    if (!tokenFile) {
+        return undefined;
+    }
+    try {
+        const fileToken = readFileSync(tokenFile, 'utf8').trim();
+        return fileToken || undefined;
+    }
+    catch {
+        throw new OpenClawGatewayError('E_BRIDGE_GATEWAY_AUTH_FILE_UNREADABLE', 'Gateway token file is unreadable');
+    }
+}
+function normalizeError(err, fallbackCode) {
+    if (err instanceof OpenClawGatewayError) {
+        return {
+            code: err.code,
+            message: err.message,
+        };
+    }
+    if (err instanceof Error) {
+        return {
+            code: fallbackCode,
+            message: err.message,
+        };
+    }
+    return {
+        code: fallbackCode,
+        message: fallbackCode,
+    };
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function normalizeAssistantMessage(value) {
+    if (!isRecord(value) || value.role !== 'assistant') {
+        return undefined;
+    }
+    const content = value.content;
+    if (typeof content === 'string') {
+        return { role: 'assistant', content };
+    }
+    if (Array.isArray(content)) {
+        const text = content
+            .map((item) => (isRecord(item) && typeof item.text === 'string' ? item.text : ''))
+            .join('');
+        if (text.length > 0) {
+            return { role: 'assistant', content: text };
+        }
+    }
+    return undefined;
+}
+function hasNonEmptyList(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function parseFileRef(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const downloadUrl = textParam(value, 'downloadUrl');
+    const mimeType = normalizeMimeType(textParam(value, 'mimeType'));
+    const fileName = textParam(value, 'fileName') ?? textParam(value, 'originalName') ?? 'attachment';
+    if (!downloadUrl) {
+        return undefined;
+    }
+    return {
+        fileName,
+        mimeType,
+        downloadUrl,
+        sizeBytes: longParam(value, 'sizeBytes'),
+        sha256: textParam(value, 'sha256'),
+    };
+}
+function normalizeMimeType(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized ? normalized : DEFAULT_MIME_TYPE;
+}
+function parseContentLength(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+async function fetchWithTimeout(fetchImpl, input, init, timeoutMs, timeoutCode, timeoutMessage) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, Math.max(1, timeoutMs));
+    try {
+        return await fetchImpl(input, {
+            ...(init ?? {}),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (timedOut || isAbortError(err)) {
+            throw new OpenClawGatewayError(timeoutCode, timeoutMessage);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function isAbortError(err) {
+    return err instanceof DOMException && err.name === 'AbortError';
+}
+async function readResponseBytes(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.byteLength > maxBytes) {
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRef exceeds size limit');
+        }
+        return bytes;
+    }
+    const chunks = [];
+    let totalBytes = 0;
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (!value) {
+            continue;
+        }
+        totalBytes += value.byteLength;
+        if (totalBytes > maxBytes) {
+            await reader.cancel();
+            throw new OpenClawGatewayError('E_BRIDGE_ATTACHMENT_TOO_LARGE', 'fileRef exceeds size limit');
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function arrayBufferCopy(bytes) {
+    const copy = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(copy).set(bytes);
+    return copy;
+}
+// 从 webchat final 消息的 content blocks 中抽取可回传的媒体（assistant 本轮产出）。
+// 镜像 OpenClaw artifacts.ts 的 isArtifactBlock / resolveBlockDownload 取值逻辑，但只保留
+// 两类安全来源：内联 data URL（本地解码）与 gateway 托管媒体路径（回源 fetch）。
+function extractOutboundMediaBlocks(message) {
+    if (!isRecord(message)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of Array.isArray(message.content) ? message.content : []) {
+        if (!isRecord(raw) || !isOutboundMediaBlock(raw)) {
+            continue;
+        }
+        const resolved = resolveOutboundBlockSource(raw);
+        if (!resolved) {
+            continue;
+        }
+        const type = normalizeOutboundMediaType(textParam(raw, 'type'));
+        const title = textParam(raw, 'title')
+            ?? textParam(raw, 'fileName')
+            ?? textParam(raw, 'filename')
+            ?? textParam(raw, 'alt');
+        const mimeType = normalizeMimeType(resolved.mimeType);
+        const fileName = title ?? defaultOutboundFileName(type, mimeType, resolved.artifactId);
+        out.push({ artifactId: resolved.artifactId, fileName, mimeType, source: resolved.source });
+    }
+    for (const mediaUrl of extractStructuredMediaUrls(message)) {
+        const resolved = resolveOutboundMediaUrlSource(mediaUrl, message);
+        if (!resolved) {
+            continue;
+        }
+        const mimeType = normalizeMimeType(resolved.mimeType);
+        const fileName = structuredMediaFileName(message, mimeType, resolved.artifactId);
+        out.push({ artifactId: resolved.artifactId, fileName, mimeType, source: resolved.source });
+    }
+    return out;
+}
+function isOutboundMediaBlock(block) {
+    const type = textParam(block, 'type')?.toLowerCase();
+    if (type === 'image' || type === 'input_image' || type === 'image_url'
+        || type === 'audio' || type === 'input_audio'
+        || type === 'file' || type === 'input_file') {
+        return true;
+    }
+    return Boolean(block.url || block.openUrl || block.data || block.source || block.image_url || block.audio_url);
+}
+function resolveOutboundBlockSource(block) {
+    const source = isRecord(block.source) ? block.source : undefined;
+    const data = textParam(block, 'data');
+    const contentVal = textParam(block, 'content');
+    const url = textParam(block, 'url') ?? textParam(block, 'openUrl');
+    const imageUrl = mediaUrlValue(block.image_url);
+    const audioUrl = textParam(block, 'audio_url');
+    const sourceData = source ? textParam(source, 'data') : undefined;
+    const sourceUrl = source ? textParam(source, 'url') : undefined;
+    const dataUrl = [url, sourceUrl, imageUrl, audioUrl, data, contentVal, sourceData]
+        .find((value) => typeof value === 'string' && /^data:/i.test(value));
+    const mimeType = textParam(block, 'mimeType')
+        ?? textParam(block, 'media_type')
+        ?? (source ? (textParam(source, 'media_type') ?? textParam(source, 'mimeType')) : undefined)
+        ?? (dataUrl ? mimeFromDataUrl(dataUrl) : undefined);
+    if (dataUrl) {
+        const base64 = base64FromDataUrl(dataUrl);
+        if (base64) {
+            return { source: { kind: 'data', base64 }, mimeType, artifactId: `sha_${sha256HexOfBase64(base64).slice(0, 24)}` };
+        }
+    }
+    // base64 直接放在显式 source.data（图片/音频块的标准形态）。
+    if (sourceData && !/^data:/i.test(sourceData) && isLikelyBase64(sourceData)) {
+        return { source: { kind: 'data', base64: sourceData }, mimeType, artifactId: `sha_${sha256HexOfBase64(sourceData).slice(0, 24)}` };
+    }
+    const managed = [url, sourceUrl, imageUrl, audioUrl]
+        .find((value) => typeof value === 'string' && isManagedMediaUrl(value));
+    if (managed) {
+        return { source: { kind: 'managed', url: managed }, mimeType, artifactId: managedMediaArtifactId(managed) };
+    }
+    return undefined;
+}
+function resolveOutboundMediaUrlSource(mediaUrl, record) {
+    const mimeType = textParam(record, 'mimeType')
+        ?? textParam(record, 'media_type')
+        ?? textParam(record, 'mime_type');
+    if (/^data:/i.test(mediaUrl)) {
+        const base64 = base64FromDataUrl(mediaUrl);
+        if (!base64) {
+            return undefined;
+        }
+        return {
+            source: { kind: 'data', base64 },
+            mimeType: mimeType ?? mimeFromDataUrl(mediaUrl),
+            artifactId: `sha_${sha256HexOfBase64(base64).slice(0, 24)}`,
+        };
+    }
+    if (isManagedMediaUrl(mediaUrl)) {
+        return {
+            source: { kind: 'managed', url: mediaUrl },
+            mimeType,
+            artifactId: managedMediaArtifactId(mediaUrl),
+        };
+    }
+    return undefined;
+}
+function extractStructuredMediaUrls(message) {
+    const raw = [];
+    for (const key of ['media', 'mediaUrl', 'media_url', 'fileUrl', 'file_url']) {
+        const value = textParam(message, key);
+        if (value) {
+            raw.push(value);
+        }
+    }
+    for (const key of ['mediaUrls', 'media_urls']) {
+        const value = message[key];
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        for (const item of value) {
+            if (typeof item === 'string' && item.trim()) {
+                raw.push(item.trim());
+            }
+        }
+    }
+    return raw;
+}
+function structuredMediaFileName(record, mimeType, artifactId) {
+    return textParam(record, 'fileName')
+        ?? textParam(record, 'filename')
+        ?? textParam(record, 'name')
+        ?? textParam(record, 'title')
+        ?? defaultOutboundFileName(mediaTypeForMime(mimeType), mimeType, artifactId);
+}
+function mediaTypeForMime(mimeType) {
+    if (mimeType.startsWith('image/')) {
+        return 'image';
+    }
+    if (mimeType.startsWith('audio/')) {
+        return 'audio';
+    }
+    return 'file';
+}
+function normalizeOutboundMediaType(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === 'image' || normalized === 'input_image' || normalized === 'image_url') {
+        return 'image';
+    }
+    if (normalized === 'audio' || normalized === 'input_audio') {
+        return 'audio';
+    }
+    return 'file';
+}
+function defaultOutboundFileName(type, mimeType, artifactId) {
+    const subtype = mimeType.includes('/') ? mimeType.split('/')[1] ?? '' : '';
+    const cleaned = subtype.replace(/\+.*$/, '');
+    const ext = cleaned && /^[a-z0-9.-]+$/.test(cleaned)
+        ? `.${cleaned === 'jpeg' ? 'jpg' : cleaned}`
+        : (type === 'image' ? '.png' : type === 'audio' ? '.mp3' : '.bin');
+    return `${type}-${artifactId}${ext}`;
+}
+function mediaUrlValue(value) {
+    if (typeof value === 'string') {
+        return value.length > 0 ? value : undefined;
+    }
+    if (isRecord(value)) {
+        return textParam(value, 'url');
+    }
+    return undefined;
+}
+function base64FromDataUrl(value) {
+    const trimmed = value.trim();
+    const commaIndex = trimmed.indexOf(',');
+    if (commaIndex < 0 || trimmed.slice(0, 5).toLowerCase() !== 'data:') {
+        return undefined;
+    }
+    const meta = trimmed.slice(0, commaIndex);
+    if (!/;base64$/i.test(meta)) {
+        return undefined;
+    }
+    const payload = trimmed.slice(commaIndex + 1).trim();
+    return payload.length > 0 ? payload : undefined;
+}
+function mimeFromDataUrl(value) {
+    const match = /^data:([^;,]+)(?:;[^,]*)?,/i.exec(value.trim());
+    return match?.[1]?.toLowerCase();
+}
+function isManagedMediaUrl(value) {
+    try {
+        const parsed = new URL(value, 'http://localhost');
+        return parsed.pathname.startsWith(MANAGED_MEDIA_PATH_PREFIX);
+    }
+    catch {
+        return false;
+    }
+}
+function managedMediaArtifactId(value) {
+    try {
+        const parsed = new URL(value, 'http://localhost');
+        // /api/chat/media/outgoing/<sessionKey>/<attachmentId>/<variant>
+        const segments = parsed.pathname.slice(MANAGED_MEDIA_PATH_PREFIX.length).split('/').filter(Boolean);
+        const attachmentId = segments[1];
+        if (attachmentId) {
+            return attachmentId;
+        }
+    }
+    catch {
+        // fall through to hashing the raw url
+    }
+    return `url_${createHash('sha256').update(value).digest('hex').slice(0, 24)}`;
+}
+function isLikelyBase64(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 8) {
+        return false;
+    }
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(trimmed);
+}
+function sha256HexOfBase64(base64) {
+    return createHash('sha256').update(Buffer.from(base64, 'base64')).digest('hex');
+}
+function collectMessageText(message) {
+    if (!isRecord(message)) {
+        return '';
+    }
+    const content = message.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .map((block) => (isRecord(block) && typeof block.text === 'string' ? block.text : ''))
+        .filter((text) => text.length > 0)
+        .join('\n');
+}
+// 从 assistant final 文本里抽取候选本地文件路径:markdown 链接目标 + 防御性的 MEDIA: 行。
+function parseFileCandidatesFromText(text) {
+    if (!text) {
+        return [];
+    }
+    const raw = [];
+    const mdLink = /\[[^\]]*\]\(\s*(<[^>]+>|[^)\s]+)/g;
+    let match;
+    while ((match = mdLink.exec(text)) !== null) {
+        let target = match[1].trim();
+        if (target.startsWith('<') && target.endsWith('>')) {
+            target = target.slice(1, -1);
+        }
+        raw.push(target);
+    }
+    const mediaLine = /^\s*MEDIA:\s*(\S+)/gim;
+    while ((match = mediaLine.exec(text)) !== null) {
+        raw.push(match[1].trim());
+    }
+    return raw.map(decodeFileTarget).filter(isLocalPathCandidate);
+}
+function extractStructuredLocalFileCandidates(message) {
+    if (!isRecord(message)) {
+        return [];
+    }
+    const raw = [];
+    for (const key of ['path', 'filePath', 'file_path', 'media', 'fileUrl', 'file_url']) {
+        const value = textParam(message, key);
+        if (value) {
+            raw.push(value);
+        }
+    }
+    for (const mediaUrl of extractStructuredMediaUrls(message)) {
+        raw.push(mediaUrl);
+    }
+    return raw.map(decodeFileTarget).filter(isLocalPathCandidate);
+}
+function decodeFileTarget(target) {
+    try {
+        return decodeURIComponent(target);
+    }
+    catch {
+        return target;
+    }
+}
+// 排除带协议的 URL(http/https/data/mailto…)、协议相对链接、页内锚点;只留本地路径候选。
+function isLocalPathCandidate(target) {
+    if (!target) {
+        return false;
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target)) {
+        return false;
+    }
+    if (target.startsWith('//') || target.startsWith('#')) {
+        return false;
+    }
+    return true;
+}
+function isInsideRoots(real, roots) {
+    return roots.some((root) => real === root || real.startsWith(root + pathSep));
+}
+function mimeForFileName(fileName) {
+    const dot = fileName.lastIndexOf('.');
+    const ext = dot >= 0 ? fileName.slice(dot + 1).toLowerCase() : '';
+    return FILE_EXT_MIME[ext] ?? DEFAULT_MIME_TYPE;
+}
+function readOpenClawWorkspaceDir(configPath) {
+    try {
+        const path = configPath ?? process.env.OPENCLAW_CONFIG ?? joinPath(homedir(), '.openclaw', 'openclaw.json');
+        const cfg = JSON.parse(readFileSync(path, 'utf8'));
+        const agents = isRecord(cfg.agents) ? cfg.agents : undefined;
+        const defaults = agents && isRecord(agents.defaults) ? agents.defaults : undefined;
+        const workspace = defaults ? defaults.workspace : undefined;
+        return typeof workspace === 'string' && workspace.trim() ? workspace.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function textParam(params, key) {
+    const value = params[key];
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return undefined;
+}
+function longParam(params, key) {
+    const value = params[key];
+    if (typeof value === 'number' && Number.isSafeInteger(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && /^\d+$/.test(value)) {
+        const parsed = Number(value);
+        return Number.isSafeInteger(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=openclaw-chat-runtime.js.map