@botlearn-course/daemon 0.0.1

package/dist/runtimes/openclaw-acp.js

@@ -0,0 +1,872 @@
+import { spawn } from "node:child_process";
+import { readCommandVersion, resolveCommandOnPath } from "./probe.js";
+import { sliceUtf8Bytes } from "./text-cap.js";
+import { consoleLogger, wrapEngineAdapter, } from "./engine.js";
+const log = consoleLogger;
+const ACP_PROTOCOL_VERSION = 1;
+/** 空闲（无 in-flight prompt）ACP 子进程的存活时长。 */
+const ACP_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+/** 单轮流式 assistant 文本字节上限。 */
+const ASSISTANT_TEXT_CAP = 1 * 1024 * 1024;
+/** sessionKey 里代表本 daemon 的固定身份段（单用户 daemon，无多账号语义）。 */
+const ACP_ACCOUNT_ID = "course-daemon";
+export function resolveOpenclawGatewayFromEnv(env = process.env) {
+    const url = env.BOTLEARN_OPENCLAW_URL?.trim();
+    if (!url)
+        return null;
+    return {
+        url,
+        token: env.BOTLEARN_OPENCLAW_TOKEN?.trim() || undefined,
+        openclawAgent: env.BOTLEARN_OPENCLAW_AGENT?.trim() || undefined,
+    };
+}
+const ACP_POOL = new Map();
+const POOL_KEY = "env";
+let exitCleanupHookInstalled = false;
+/** daemon 退出时杀掉池中子进程，避免孤儿。首次 spawn 时惰性安装。 */
+function installExitCleanupHook() {
+    if (exitCleanupHookInstalled)
+        return;
+    exitCleanupHookInstalled = true;
+    process.once("exit", () => {
+        for (const [key, h] of ACP_POOL.entries()) {
+            shutdownHandle(h, "daemon-exit");
+            ACP_POOL.delete(key);
+        }
+    });
+}
+function resetIdle(h, key) {
+    if (h.idleTimer)
+        clearTimeout(h.idleTimer);
+    if (h.inFlight > 0)
+        return;
+    h.idleTimer = setTimeout(() => {
+        if (h.inFlight === 0 && !h.closed) {
+            log.info("openclaw-acp.idle-timeout", { key });
+            shutdownHandle(h, "idle-timeout");
+            ACP_POOL.delete(key);
+        }
+    }, ACP_IDLE_TIMEOUT_MS);
+    h.idleTimer.unref?.();
+}
+function shutdownHandle(h, reason) {
+    if (h.closed)
+        return;
+    h.closed = true;
+    h.exitReason = reason;
+    if (h.idleTimer)
+        clearTimeout(h.idleTimer);
+    for (const p of h.pending.values()) {
+        p.reject(new Error(`openclaw acp child closed: ${reason}`));
+    }
+    h.pending.clear();
+    h.subscribers.clear();
+    try {
+        h.child.kill("SIGTERM");
+    }
+    catch {
+        // already dead
+    }
+}
+/** 仅测试用：清空进程池。 */
+export function __resetOpenclawAcpPoolForTests() {
+    for (const [key, h] of ACP_POOL.entries()) {
+        shutdownHandle(h, "test-reset");
+        ACP_POOL.delete(key);
+    }
+}
+// ---------------------------------------------------------------------------
+// Probe
+// ---------------------------------------------------------------------------
+function resolveOpenclawCommand(deps = {}) {
+    const explicit = (deps.env ?? process.env).BOTLEARN_OPENCLAW_BIN;
+    if (explicit && explicit.length > 0)
+        return explicit;
+    return resolveCommandOnPath("openclaw", deps);
+}
+/** 可用 = 二进制在 PATH 上且 BOTLEARN_OPENCLAW_URL 已配置。 */
+export function probeOpenclaw(deps = {}) {
+    const command = resolveOpenclawCommand(deps);
+    if (!command)
+        return { available: false };
+    const version = readCommandVersion(command, [], deps) ?? undefined;
+    const gateway = resolveOpenclawGatewayFromEnv(deps.env ?? process.env);
+    if (!gateway) {
+        return { available: false, path: command, version };
+    }
+    return { available: true, path: command, version };
+}
+/**
+ * OpenClaw ACP 引擎。spawn `openclaw acp --url <gateway> [--token <token>]`
+ * 并跨 run 复用子进程（stdio JSON-RPC）；网关端点仅来自
+ * BOTLEARN_OPENCLAW_URL / BOTLEARN_OPENCLAW_TOKEN / BOTLEARN_OPENCLAW_AGENT。
+ * 每 run 用 `_meta.sessionKey`（含 cwd，即 run 工作区）标识稳定会话；
+ * 缓存的 ACP sessionId 只是传输层句柄，load 失败即丢弃重建。
+ *
+ * 权限姿态：course run 在 owner 本机工作区执行，网关侧的权限策略由
+ * OpenClaw 自身配置决定，daemon 不代答权限请求（ACP acp 模式无 reverse-call）。
+ */
+export class OpenclawAcpAdapter {
+    id = "openclaw-acp";
+    spawnFn;
+    env;
+    constructor(deps = {}) {
+        this.spawnFn = deps.spawnFn ?? spawn;
+        this.env = deps.env;
+    }
+    async run(opts) {
+        const gateway = resolveOpenclawGatewayFromEnv(this.env ?? process.env);
+        if (!gateway) {
+            return failResult(opts.sessionId ?? "", "openclaw-acp: missing gateway endpoint (set BOTLEARN_OPENCLAW_URL, optional BOTLEARN_OPENCLAW_TOKEN / BOTLEARN_OPENCLAW_AGENT)");
+        }
+        const openclawAgent = gateway.openclawAgent ?? "default";
+        // conversationKey 用 run 工作区路径：每个 course run 的工作区唯一，
+        // 网关侧因此每 run 一个会话，不会与其他 run 串话。
+        const sessionKey = buildAcpSessionKey({
+            openclawAgent,
+            accountId: ACP_ACCOUNT_ID,
+            conversationKey: opts.cwd || "default",
+        });
+        let handle;
+        try {
+            handle = await this.acquireHandle(POOL_KEY, gateway);
+        }
+        catch (err) {
+            return failResult(opts.sessionId ?? "", `openclaw-acp: ${err.message}`);
+        }
+        handle.inFlight += 1;
+        if (handle.idleTimer)
+            clearTimeout(handle.idleTimer);
+        let acpSessionId = opts.sessionId ?? "";
+        let seq = 0;
+        let assistantText = "";
+        let assistantBytes = 0;
+        let capped = false;
+        let finalText = "";
+        const assistantTextFilter = createAssistantTextFilter();
+        const emitBlock = (block) => {
+            try {
+                opts.onBlock?.(block);
+            }
+            catch (err) {
+                log.warn("openclaw-acp.onBlock-threw", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        };
+        const onNotification = (note) => {
+            const update = note.params?.update;
+            if (update?.sessionUpdate === "agent_message_chunk") {
+                const text = assistantTextFilter.push(extractText(update.content));
+                if (text && !capped) {
+                    const bytes = Buffer.byteLength(text, "utf8");
+                    if (assistantBytes + bytes > ASSISTANT_TEXT_CAP) {
+                        const chunk = sliceUtf8Bytes(text, ASSISTANT_TEXT_CAP - assistantBytes);
+                        if (chunk) {
+                            assistantText += chunk;
+                            assistantBytes += Buffer.byteLength(chunk, "utf8");
+                        }
+                        capped = true;
+                    }
+                    else {
+                        assistantText += text;
+                        assistantBytes += bytes;
+                    }
+                }
+                if (!text)
+                    return;
+                seq += 1;
+                emitBlock({ raw: sanitizeAssistantChunk(note, text), kind: "assistant_text", seq });
+                return;
+            }
+            seq += 1;
+            const kind = classifyAcpUpdate(note);
+            emitBlock({ raw: note, kind, seq });
+        };
+        let abortListener;
+        try {
+            // 缓存的 ACP sessionId 先 load 重绑；句柄已失效则丢弃重建。
+            if (acpSessionId) {
+                try {
+                    acpSessionId = await this.loadSession(handle, {
+                        sessionId: acpSessionId,
+                        cwd: opts.cwd,
+                        sessionKey,
+                    });
+                }
+                catch (err) {
+                    if (!isSessionNotFoundError(err))
+                        throw err;
+                    log.warn("openclaw-acp.session-load-not-found", {
+                        oldSessionId: acpSessionId,
+                        sessionKey,
+                    });
+                    acpSessionId = "";
+                }
+            }
+            if (!acpSessionId) {
+                try {
+                    acpSessionId = await this.newSession(handle, {
+                        cwd: opts.cwd,
+                        sessionKey,
+                    });
+                }
+                catch (err) {
+                    throw new Error(`newSession failed: ${err.message}`);
+                }
+            }
+            handle.subscribers.set(acpSessionId, onNotification);
+            if (opts.signal?.aborted) {
+                return failResult(acpSessionId, "openclaw-acp: aborted before prompt");
+            }
+            abortListener = () => {
+                // best-effort 取消；ACP cancel 是通知（fire-and-forget）。
+                sendNotification(handle, "session/cancel", { sessionId: acpSessionId });
+            };
+            opts.signal?.addEventListener("abort", abortListener);
+            let promptResult;
+            try {
+                promptResult = await this.prompt(handle, {
+                    sessionId: acpSessionId,
+                    text: opts.text,
+                });
+            }
+            catch (err) {
+                // 子进程侧会话丢失（重启、GC）→ 重建后重试一次。
+                if (isSessionNotFoundError(err)) {
+                    try {
+                        const oldSessionId = acpSessionId;
+                        log.warn("openclaw-acp.prompt-session-not-found-retry", {
+                            oldSessionId,
+                            sessionKey,
+                        });
+                        const fresh = await this.newSession(handle, {
+                            cwd: opts.cwd,
+                            sessionKey,
+                        });
+                        handle.subscribers.delete(acpSessionId);
+                        acpSessionId = fresh;
+                        handle.subscribers.set(acpSessionId, onNotification);
+                        log.info("openclaw-acp.session-recreated", {
+                            oldSessionId,
+                            newSessionId: acpSessionId,
+                            sessionKey,
+                        });
+                        promptResult = await this.prompt(handle, {
+                            sessionId: acpSessionId,
+                            text: opts.text,
+                        });
+                    }
+                    catch (err2) {
+                        throw new Error(`prompt failed after session reset: ${err2.message}`);
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+            // prompt 响应 shape 不完全固定：先从常见位置取最终文本，
+            // 取不到再回退到流式累积的 chunk。
+            const tailText = assistantTextFilter.flush();
+            if (tailText && !capped) {
+                const bytes = Buffer.byteLength(tailText, "utf8");
+                const textForBlock = assistantBytes + bytes <= ASSISTANT_TEXT_CAP
+                    ? tailText
+                    : sliceUtf8Bytes(tailText, ASSISTANT_TEXT_CAP - assistantBytes);
+                if (textForBlock) {
+                    assistantText += textForBlock;
+                    assistantBytes += Buffer.byteLength(textForBlock, "utf8");
+                    if (textForBlock !== tailText)
+                        capped = true;
+                    seq += 1;
+                    emitBlock({
+                        raw: {
+                            method: "session/update",
+                            params: {
+                                sessionId: acpSessionId,
+                                update: {
+                                    sessionUpdate: "agent_message_chunk",
+                                    content: [{ type: "text", text: textForBlock }],
+                                },
+                            },
+                        },
+                        kind: "assistant_text",
+                        seq,
+                    });
+                }
+            }
+            const pickedText = normalizeAssistantText(pickFinalText(promptResult));
+            const streamedText = normalizeAssistantText(assistantText);
+            finalText = pickSafeAssistantText(pickedText) || pickSafeAssistantText(streamedText);
+            if (capped) {
+                log.warn("openclaw-acp.assistant-text-capped", { sessionId: acpSessionId });
+            }
+            if (!finalText) {
+                const stopReason = pickStopReason(promptResult);
+                if (!stopReason || stopReason === "end_turn") {
+                    return {
+                        text: "",
+                        newSessionId: acpSessionId,
+                    };
+                }
+                // stdout 非 JSON 尾部往往是 OpenClaw 配置告警（缺 API key 等），
+                // 附进错误里帮助定位。
+                const warningTail = handle.nonJsonStdoutTail.slice(-8).join("\n").trim();
+                const detail = warningTail ? `; stdout: ${truncateDetail(warningTail, 1000)}` : "";
+                const reason = stopReason ? `prompt stopped: ${stopReason}` : "empty assistant response";
+                return failResult(acpSessionId, `openclaw-acp: ${reason}${detail}`);
+            }
+            return {
+                text: finalText,
+                newSessionId: acpSessionId,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return failResult(isSessionNotFoundError(err) ? "" : acpSessionId, `openclaw-acp: ${message}`);
+        }
+        finally {
+            if (abortListener && opts.signal) {
+                try {
+                    opts.signal.removeEventListener("abort", abortListener);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            handle.subscribers.delete(acpSessionId);
+            handle.inFlight = Math.max(0, handle.inFlight - 1);
+            resetIdle(handle, POOL_KEY);
+        }
+    }
+    // ---------------------------------------------------------------------
+    // 进程管理
+    // ---------------------------------------------------------------------
+    async acquireHandle(key, gateway) {
+        let handle = ACP_POOL.get(key);
+        if (handle && handle.closed) {
+            ACP_POOL.delete(key);
+            handle = undefined;
+        }
+        // env 改变（url/token 轮换）后不得继续用旧 --url/--token 的子进程。
+        if (handle && (handle.spawnedUrl !== gateway.url || handle.spawnedToken !== gateway.token)) {
+            log.info("openclaw-acp.gateway-args-changed", {
+                key,
+                oldUrl: handle.spawnedUrl,
+                newUrl: gateway.url,
+                tokenChanged: handle.spawnedToken !== gateway.token,
+            });
+            shutdownHandle(handle, "gateway-args-changed");
+            ACP_POOL.delete(key);
+            handle = undefined;
+        }
+        if (!handle) {
+            handle = this.spawnAcpProcess(key, gateway);
+            ACP_POOL.set(key, handle);
+        }
+        if (!handle.initialized) {
+            if (!handle.initializePromise) {
+                handle.initializePromise = sendRequest(handle, "initialize", {
+                    protocolVersion: ACP_PROTOCOL_VERSION,
+                    clientCapabilities: {},
+                }).then(() => {
+                    handle.initialized = true;
+                });
+            }
+            await handle.initializePromise;
+        }
+        return handle;
+    }
+    spawnAcpProcess(key, gateway) {
+        const command = resolveOpenclawCommand({ env: this.env }) ?? "openclaw";
+        const args = ["acp", "--url", gateway.url];
+        if (gateway.token)
+            args.push("--token", gateway.token);
+        const child = this.spawnFn(command, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env },
+        });
+        installExitCleanupHook();
+        const handle = {
+            child,
+            pending: new Map(),
+            subscribers: new Map(),
+            nextId: 1,
+            buffer: "",
+            nonJsonStdoutTail: [],
+            initialized: false,
+            inFlight: 0,
+            closed: false,
+            spawnedUrl: gateway.url,
+            spawnedToken: gateway.token,
+        };
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => onStdoutChunk(handle, chunk));
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            log.debug("openclaw-acp.stderr", { key, chunk: chunk.slice(0, 500) });
+        });
+        child.on("exit", (code, signal) => {
+            shutdownHandle(handle, `exit code=${code ?? "null"} signal=${signal ?? "null"}`);
+            ACP_POOL.delete(key);
+        });
+        child.on("error", (err) => {
+            log.warn("openclaw-acp.child-error", {
+                key,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            shutdownHandle(handle, `error: ${err.message}`);
+            ACP_POOL.delete(key);
+        });
+        return handle;
+    }
+    async newSession(handle, args) {
+        const result = (await sendRequest(handle, "session/new", {
+            cwd: args.cwd,
+            mcpServers: [],
+            _meta: { sessionKey: args.sessionKey },
+        }));
+        if (!result?.sessionId || typeof result.sessionId !== "string") {
+            throw new Error("newSession returned no sessionId");
+        }
+        return result.sessionId;
+    }
+    async loadSession(handle, args) {
+        const result = (await sendRequest(handle, "session/load", {
+            sessionId: args.sessionId,
+            cwd: args.cwd,
+            mcpServers: [],
+            _meta: { sessionKey: args.sessionKey },
+        }));
+        if (result?.sessionId && typeof result.sessionId === "string") {
+            return result.sessionId;
+        }
+        return args.sessionId;
+    }
+    async prompt(handle, args) {
+        return sendRequest(handle, "session/prompt", {
+            sessionId: args.sessionId,
+            prompt: [{ type: "text", text: args.text }],
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON-RPC stdio plumbing
+// ---------------------------------------------------------------------------
+function onStdoutChunk(handle, chunk) {
+    handle.buffer += chunk;
+    let idx;
+    while ((idx = handle.buffer.indexOf("\n")) !== -1) {
+        const line = handle.buffer.slice(0, idx).trim();
+        handle.buffer = handle.buffer.slice(idx + 1);
+        if (!line)
+            continue;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch (err) {
+            handle.nonJsonStdoutTail.push(line.slice(0, 500));
+            if (handle.nonJsonStdoutTail.length > 20) {
+                handle.nonJsonStdoutTail.splice(0, handle.nonJsonStdoutTail.length - 20);
+            }
+            log.warn("openclaw-acp.parse-error", {
+                error: err instanceof Error ? err.message : String(err),
+                line: line.slice(0, 200),
+            });
+            continue;
+        }
+        routeMessage(handle, msg);
+    }
+}
+function routeMessage(handle, msg) {
+    if (msg && typeof msg === "object" && "id" in msg && ("result" in msg || "error" in msg)) {
+        const id = typeof msg.id === "number" ? msg.id : Number(msg.id);
+        const pending = handle.pending.get(id);
+        if (!pending)
+            return;
+        handle.pending.delete(id);
+        if (msg.error) {
+            pending.reject(new Error(formatRpcError(msg.error)));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+        return;
+    }
+    // 通知。
+    if (msg?.method && msg?.params) {
+        const sid = msg.params?.sessionId;
+        if (typeof sid === "string") {
+            const sub = handle.subscribers.get(sid);
+            if (sub) {
+                try {
+                    sub({ method: msg.method, params: msg.params });
+                }
+                catch (err) {
+                    log.warn("openclaw-acp.subscriber-threw", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+    }
+}
+function sendRequest(handle, method, params) {
+    if (handle.closed)
+        return Promise.reject(new Error("acp child closed"));
+    return new Promise((resolve, reject) => {
+        const id = handle.nextId++;
+        handle.pending.set(id, { resolve, reject, method });
+        const frame = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+        try {
+            handle.child.stdin.write(frame);
+        }
+        catch (err) {
+            handle.pending.delete(id);
+            reject(err);
+        }
+    });
+}
+function sendNotification(handle, method, params) {
+    if (handle.closed)
+        return;
+    const frame = JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n";
+    try {
+        handle.child.stdin.write(frame);
+    }
+    catch {
+        // best-effort fire-and-forget
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function failResult(sessionId, error) {
+    return {
+        text: "",
+        newSessionId: sessionId,
+        error,
+    };
+}
+function formatRpcError(error) {
+    if (!error || typeof error !== "object")
+        return "rpc error";
+    const e = error;
+    const message = typeof e.message === "string" ? e.message : "rpc error";
+    const data = e.data;
+    if (data && typeof data === "object") {
+        const details = data.details;
+        if (typeof details === "string" && details.length > 0) {
+            return `${message}: ${details}`;
+        }
+    }
+    return message;
+}
+function isSessionNotFoundError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /session(?:\s+[\w-]+)?\s+not\s+found|unknown\s+session/i.test(msg);
+}
+function classifyAcpUpdate(note) {
+    const update = note.params?.update;
+    const kind = update?.sessionUpdate;
+    switch (kind) {
+        case "agent_message_chunk":
+            return "assistant_text";
+        case "tool_call":
+            return "tool_use";
+        case "tool_call_update":
+            return "tool_result";
+        case "session_info_update":
+        case "available_commands_update":
+        case "usage_update":
+            return "system";
+        default:
+            return "other";
+    }
+}
+function extractText(content) {
+    if (!content)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map(extractText).join("");
+    }
+    if (typeof content === "object") {
+        const c = content;
+        const type = typeof c.type === "string" ? c.type.toLowerCase() : "";
+        if (type === "thinking" || type === "reasoning" || type === "thought")
+            return "";
+        if (typeof c.text === "string")
+            return c.text;
+        if (typeof c.content === "string")
+            return c.content;
+        if (Array.isArray(c.content))
+            return extractText(c.content);
+    }
+    return "";
+}
+function sanitizeAssistantChunk(note, text) {
+    return {
+        ...note,
+        params: {
+            ...note.params,
+            update: {
+                ...note.params?.update,
+                content: [{ type: "text", text }],
+            },
+        },
+    };
+}
+function normalizeAssistantText(text) {
+    if (!text)
+        return "";
+    const finalMatch = text.match(/<final>([\s\S]*?)<\/final>/i);
+    const selected = finalMatch ? finalMatch[1] : text;
+    if (!finalMatch && selected.trimStart().toLowerCase().startsWith("<think")) {
+        return "";
+    }
+    return stripLeadingBoundaryResidue(selected
+        .replace(/<think[^>]*>[\s\S]*?<\/think>/gi, "")
+        .replace(/<\/?final>/gi, "")
+        .trim());
+}
+function stripLeadingBoundaryResidue(text) {
+    if (!text.startsWith("<"))
+        return text;
+    // 保留真实 HTML/XML 风格标签与比较运算符；孤立的前导 "<" 是 ACP 把
+    // 结构边界标记与正文分开流式发送时的残留。
+    if (startsWithRealAngleSyntax(text))
+        return text;
+    return text.slice(1).trimStart();
+}
+function startsWithRealAngleSyntax(text) {
+    return /^<\/?[A-Za-z][A-Za-z0-9:-]*(?:\s|>|\/>)/.test(text) || /^<(?:\s|=|<)/.test(text);
+}
+function createAssistantTextFilter() {
+    let pending = "";
+    let inThink = false;
+    let inFinal = false;
+    let seenFinal = false;
+    let fallback = "";
+    const consume = (flush) => {
+        let out = "";
+        while (pending.length > 0) {
+            if (inThink) {
+                const close = pending.search(/<\/think>/i);
+                if (close === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(close).replace(/^<\/think>/i, "");
+                inThink = false;
+                continue;
+            }
+            if (inFinal) {
+                const close = pending.search(/<\/final>/i);
+                if (close === -1) {
+                    out += pending;
+                    pending = "";
+                    return out;
+                }
+                out += pending.slice(0, close);
+                pending = pending.slice(close).replace(/^<\/final>/i, "");
+                inFinal = false;
+                continue;
+            }
+            const lt = pending.indexOf("<");
+            if (lt === -1) {
+                if (seenFinal) {
+                    out += pending;
+                }
+                else {
+                    fallback += pending;
+                }
+                pending = "";
+                return out;
+            }
+            if (lt > 0) {
+                if (seenFinal) {
+                    out += pending.slice(0, lt);
+                }
+                else {
+                    fallback += pending.slice(0, lt);
+                }
+                pending = pending.slice(lt);
+                continue;
+            }
+            const lower = pending.toLowerCase();
+            if (lower.startsWith("<think")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                inThink = true;
+                continue;
+            }
+            if (lower.startsWith("</think")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                continue;
+            }
+            if (lower.startsWith("<final")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                seenFinal = true;
+                fallback = "";
+                inFinal = true;
+                continue;
+            }
+            if (lower.startsWith("</final")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                inFinal = false;
+                continue;
+            }
+            const knownPrefixes = ["<think", "</think", "<final", "</final"];
+            if (!flush && knownPrefixes.some((prefix) => prefix.startsWith(lower))) {
+                return out;
+            }
+            if (!flush && pending === "<") {
+                return out;
+            }
+            if (!startsWithRealAngleSyntax(pending)) {
+                pending = pending.slice(1).trimStart();
+                continue;
+            }
+            if (seenFinal) {
+                out += "<";
+            }
+            else {
+                fallback += "<";
+            }
+            pending = pending.slice(1);
+        }
+        if (flush && !seenFinal && fallback) {
+            const text = normalizeAssistantText(fallback);
+            fallback = "";
+            return pickSafeAssistantText(text);
+        }
+        return out;
+    };
+    return {
+        push(text) {
+            if (!text)
+                return "";
+            pending += text;
+            return consume(false);
+        },
+        flush() {
+            return consume(true);
+        },
+    };
+}
+function pickFinalText(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const r = result;
+    if (Array.isArray(r.assistantTexts)) {
+        const text = r.assistantTexts.filter((x) => typeof x === "string").join("\n");
+        if (text.length > 0)
+            return text;
+    }
+    const contentText = extractText(r.content);
+    if (contentText.length > 0)
+        return contentText;
+    const outputText = extractText(r.output);
+    if (outputText.length > 0)
+        return outputText;
+    const responseText = extractText(r.response);
+    if (responseText.length > 0)
+        return responseText;
+    if (typeof r.text === "string" && r.text.length > 0)
+        return r.text;
+    if (typeof r.message === "string" && r.message.length > 0)
+        return r.message;
+    return undefined;
+}
+function pickStopReason(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const v = result.stopReason;
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+function truncateDetail(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max)}…`;
+}
+function looksLikeReasoningLeak(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (/^the user (said|asked|wants|is asking)\b/i.test(t) ||
+        /^i('|’)m .*\b(i('|’)ll|i will|need to|should|going to)\b/i.test(t) ||
+        /\bi('|’)ll respond\b/i.test(t) ||
+        /\bi need to\b/i.test(t));
+}
+function pickSafeAssistantText(text) {
+    if (!text)
+        return "";
+    const trimmed = text.trim();
+    if (!looksLikeReasoningLeak(trimmed))
+        return trimmed;
+    return stripLeadingReasoningLeak(trimmed);
+}
+function stripLeadingReasoningLeak(text) {
+    const paragraphs = text
+        .replace(/\r\n/g, "\n")
+        .split(/\n{2,}/)
+        .map((p) => p.trim())
+        .filter(Boolean);
+    while (paragraphs.length > 0 && isReasoningNarration(paragraphs[0])) {
+        paragraphs.shift();
+    }
+    const candidate = paragraphs.join("\n\n").trim();
+    return candidate && !looksLikeReasoningLeak(candidate) ? candidate : "";
+}
+function isReasoningNarration(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (looksLikeReasoningLeak(t) ||
+        /^let me\b/i.test(t) ||
+        /^i('|’)ll\b/i.test(t) ||
+        /^i will\b/i.test(t) ||
+        /^i should\b/i.test(t) ||
+        /^i need to\b/i.test(t));
+}
+/**
+ * 构造 OpenClaw ACP `sessionKey`。始终包含 accountId 段，避免两个 daemon
+ * 身份在同一网关上的 key 冲突。
+ */
+export function buildAcpSessionKey(args) {
+    return `agent:${args.openclawAgent}:${args.accountId}:${args.conversationKey}`;
+}
+export const openclawAcpModule = {
+    id: "openclaw-acp",
+    displayName: "OpenClaw (ACP)",
+    binary: "openclaw",
+    envVar: "BOTLEARN_OPENCLAW_BIN",
+    installHint: "Install the OpenClaw CLI (`openclaw` on PATH, or set BOTLEARN_OPENCLAW_BIN) and point BOTLEARN_OPENCLAW_URL at your gateway (optional: BOTLEARN_OPENCLAW_TOKEN, BOTLEARN_OPENCLAW_AGENT).",
+    probe: async () => probeOpenclaw(),
+    create: () => wrapEngineAdapter("openclaw-acp", new OpenclawAcpAdapter()),
+};