@botlearn-course/daemon 0.0.1

package/dist/runtimes/deepseek-tui.js

@@ -0,0 +1,701 @@
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import net from "node:net";
+import { readCommandVersion, resolveCommandOnPath } from "./probe.js";
+import { consoleLogger, wrapEngineAdapter, } from "./engine.js";
+const log = consoleLogger;
+const DEEPSEEK_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const STARTUP_TIMEOUT_MS = 30_000;
+const STARTUP_POLL_MS = 250;
+/** 单轮流式 assistant 文本字节上限。 */
+const SSE_TEXT_CAP = 1 * 1024 * 1024;
+const PROCESS_POOL = new Map();
+/** 单 daemon、单套 env 配置：池里最多一个 server。 */
+const POOL_KEY = "default";
+let exitCleanupHookInstalled = false;
+/**
+ * daemon 退出时杀掉池中 deepseek server。池是内存态的，没有这个钩子
+ * daemon 重启会留下孤儿 server。首次 spawn 时惰性安装，保持模块导入无副作用。
+ */
+function installExitCleanupHook() {
+    if (exitCleanupHookInstalled)
+        return;
+    exitCleanupHookInstalled = true;
+    process.once("exit", () => {
+        for (const [key, handle] of PROCESS_POOL.entries()) {
+            shutdownHandle(handle, "daemon-exit");
+            PROCESS_POOL.delete(key);
+        }
+    });
+}
+/** 解析 PATH 上的 `deepseek` dispatcher CLI。 */
+export function resolveDeepseekCommand(deps = {}) {
+    const explicit = (deps.env ?? process.env).BOTLEARN_DEEPSEEK_TUI_BIN;
+    if (explicit && explicit.length > 0)
+        return explicit;
+    const onPath = resolveCommandOnPath("deepseek", deps);
+    if (!onPath)
+        return null;
+    return resolveDownloadedDeepseekBinary(onPath, deps) ?? onPath;
+}
+export function probeDeepseekTui(deps = {}) {
+    const command = resolveDeepseekCommand(deps);
+    if (!command)
+        return { available: false };
+    return {
+        available: true,
+        path: command,
+        version: readCommandVersion(command, [], deps) ?? undefined,
+    };
+}
+/**
+ * DeepSeek TUI 引擎。驱动 `deepseek serve --http` 暴露的 headless runtime
+ * API（HTTP/SSE），不是交互式 TUI 也不是 ACP —— HTTP/SSE 是其文档化的完整
+ * runtime 面；ACP 目前只是保守的编辑器基线。
+ *
+ * 权限姿态：course run 在 owner 本机的隔离工作区执行，线程一律
+ * `allow_shell/trust_mode/auto_approve = true`（owner 信任，无审批人可交互）。
+ */
+export class DeepseekTuiAdapter {
+    id = "deepseek-tui";
+    explicitBinary;
+    explicitServerUrl;
+    explicitAuthToken;
+    fetchFn;
+    spawnFn;
+    resolvedBinary = null;
+    constructor(deps = {}) {
+        this.explicitBinary = deps.binary ?? process.env.BOTLEARN_DEEPSEEK_TUI_BIN;
+        this.explicitServerUrl = deps.serverUrl ?? process.env.BOTLEARN_DEEPSEEK_TUI_URL;
+        this.explicitAuthToken = deps.authToken ?? process.env.BOTLEARN_DEEPSEEK_TUI_TOKEN;
+        this.fetchFn = deps.fetchFn ?? fetch;
+        this.spawnFn = deps.spawnFn ?? spawn;
+    }
+    async run(opts) {
+        if (opts.signal.aborted) {
+            return {
+                text: "",
+                newSessionId: opts.sessionId ?? "",
+                error: "deepseek-tui aborted before start",
+            };
+        }
+        const handle = await this.acquireHandle(opts);
+        handle.inFlight += 1;
+        if (handle.idleTimer)
+            clearTimeout(handle.idleTimer);
+        const turnAbort = new AbortController();
+        const onAbort = () => turnAbort.abort();
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            const headers = authHeaders(handle.token);
+            let threadId = opts.sessionId?.trim() || "";
+            if (threadId && !isValidThreadId(threadId)) {
+                return {
+                    text: "",
+                    newSessionId: "",
+                    error: "deepseek-tui: invalid sessionId",
+                };
+            }
+            if (!threadId) {
+                threadId = await this.createThread(handle.baseUrl, headers, opts, turnAbort.signal);
+            }
+            else if (opts.systemContext !== undefined) {
+                await this.patchThreadSystemContext(handle.baseUrl, headers, threadId, opts.systemContext, turnAbort.signal);
+            }
+            const runResult = await this.startTurnAndReadEvents({
+                baseUrl: handle.baseUrl,
+                headers,
+                threadId,
+                opts,
+                signal: turnAbort.signal,
+            });
+            const text = runResult.text;
+            const error = runResult.error ?? (text === "" ? emptyCompletionError(handle.stderrTail) : undefined);
+            return {
+                text,
+                newSessionId: threadId,
+                ...(error ? { error } : {}),
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // 服务端已丢失该线程（重启、GC）→ 清空 sessionId 让下次重建。
+            const staleSession = opts.sessionId && /404|not found|missing/i.test(message);
+            return {
+                text: "",
+                newSessionId: staleSession ? "" : (opts.sessionId ?? ""),
+                error: `deepseek-tui: ${message}`,
+            };
+        }
+        finally {
+            opts.signal.removeEventListener("abort", onAbort);
+            handle.inFlight -= 1;
+            if (!this.explicitServerUrl)
+                resetIdle(handle, POOL_KEY);
+        }
+    }
+    resolveBinary() {
+        if (this.explicitBinary)
+            return this.explicitBinary;
+        if (this.resolvedBinary)
+            return this.resolvedBinary;
+        this.resolvedBinary = resolveDeepseekCommand() ?? "deepseek";
+        return this.resolvedBinary;
+    }
+    async acquireHandle(opts) {
+        if (this.explicitServerUrl) {
+            return {
+                child: nullChild(),
+                baseUrl: trimTrailingSlash(this.explicitServerUrl),
+                token: this.explicitAuthToken ?? "",
+                closed: false,
+                inFlight: 0,
+                stderrTail: "",
+            };
+        }
+        const existing = PROCESS_POOL.get(POOL_KEY);
+        if (existing && !existing.closed)
+            return existing;
+        const port = await findFreePort();
+        const token = randomToken();
+        const baseUrl = `http://127.0.0.1:${port}`;
+        const child = this.spawnFn(this.resolveBinary(), ["serve", "--http", "--host", "127.0.0.1", "--port", String(port), "--auth-token", token], {
+            cwd: opts.cwd,
+            env: this.spawnEnv(),
+            stdio: ["ignore", "pipe", "pipe"],
+            // 自成进程组：解析到的二进制可能是会再 spawn 真实 deepseek-tui
+            // server 的 dispatcher，shutdown 必须对整组发信号而非仅直接子进程。
+            detached: true,
+        });
+        installExitCleanupHook();
+        const handle = {
+            child,
+            baseUrl,
+            token,
+            closed: false,
+            inFlight: 0,
+            stderrTail: "",
+        };
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            handle.stderrTail = (handle.stderrTail + chunk).slice(-4096);
+        });
+        child.on("close", () => {
+            handle.closed = true;
+            PROCESS_POOL.delete(POOL_KEY);
+        });
+        child.on("error", () => {
+            handle.closed = true;
+            PROCESS_POOL.delete(POOL_KEY);
+        });
+        await waitForHealth(baseUrl, this.fetchFn, child, STARTUP_TIMEOUT_MS);
+        PROCESS_POOL.set(POOL_KEY, handle);
+        resetIdle(handle, POOL_KEY);
+        return handle;
+    }
+    /**
+     * 不设置 DEEPSEEK_RUNTIME_DIR：server 跨 run 池化共享，per-run 目录不成立；
+     * BYOA 直接用用户本机 deepseek 自身的默认状态目录（含已登录凭据）。
+     */
+    spawnEnv() {
+        return {
+            ...process.env,
+            FORCE_COLOR: "0",
+            NO_COLOR: "1",
+        };
+    }
+    async createThread(baseUrl, headers, opts, signal) {
+        const body = {
+            workspace: opts.cwd,
+            mode: "agent",
+            allow_shell: true,
+            trust_mode: true,
+            auto_approve: true,
+            archived: false,
+        };
+        const selection = parseDeepseekRuntimeSelection(opts.extraArgs);
+        if (selection.model)
+            body.model = selection.model;
+        if (selection.reasoningEffort)
+            body.reasoning_effort = selection.reasoningEffort;
+        if (opts.systemContext)
+            body.system_prompt = opts.systemContext;
+        const res = await this.requestJson(`${baseUrl}/v1/threads`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        const id = stringField(res, "id") ?? stringField(res, "thread_id");
+        if (!id)
+            throw new Error("create thread response missing id");
+        return id;
+    }
+    async patchThreadSystemContext(baseUrl, headers, threadId, systemContext, signal) {
+        await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}`, {
+            method: "PATCH",
+            headers,
+            body: JSON.stringify({ system_prompt: systemContext ?? "" }),
+            signal,
+        });
+    }
+    async startTurnAndReadEvents(args) {
+        const { baseUrl, headers, threadId, opts, signal } = args;
+        // 事件流必须先于 turn 打开，否则 turn 早期事件会丢。
+        const eventsUrl = `${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/events?since_seq=0`;
+        const eventsAbort = new AbortController();
+        const onAbort = () => eventsAbort.abort();
+        signal.addEventListener("abort", onAbort, { once: true });
+        let eventsError;
+        const eventsReaderPromise = this.readEvents(eventsUrl, headers, opts, eventsAbort.signal).catch((err) => {
+            eventsError = err;
+            return null;
+        });
+        try {
+            const selection = parseDeepseekRuntimeSelection(opts.extraArgs);
+            const body = {
+                prompt: opts.text,
+                mode: "agent",
+                allow_shell: true,
+                trust_mode: true,
+                auto_approve: true,
+            };
+            if (selection.model)
+                body.model = selection.model;
+            if (selection.reasoningEffort)
+                body.reasoning_effort = selection.reasoningEffort;
+            const started = await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/turns`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal,
+            });
+            const turnId = stringField(started?.turn, "id") ?? stringField(started, "turn_id") ?? "";
+            const eventsReader = await eventsReaderPromise;
+            if (!eventsReader)
+                throw eventsError ?? new Error("events stream failed");
+            return await eventsReader(turnId);
+        }
+        finally {
+            eventsAbort.abort();
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+    async readEvents(url, headers, opts, signal) {
+        const res = await this.fetchFn(url, { method: "GET", headers, signal });
+        if (!res.ok)
+            throw new Error(`events stream failed HTTP ${res.status}`);
+        if (!res.body)
+            throw new Error("events stream response missing body");
+        const reader = res.body.getReader();
+        return async (turnId) => {
+            const decoder = new TextDecoder();
+            let buf = "";
+            let seq = 0;
+            let text = "";
+            let errorText = "";
+            let capped = false;
+            const append = (chunk) => {
+                if (!chunk || capped)
+                    return;
+                const budget = SSE_TEXT_CAP - Buffer.byteLength(text, "utf8");
+                if (budget <= 0) {
+                    capped = true;
+                    return;
+                }
+                if (Buffer.byteLength(chunk, "utf8") > budget) {
+                    text += chunk.slice(0, budget);
+                    capped = true;
+                    return;
+                }
+                text += chunk;
+            };
+            const emit = (eventName, payload) => {
+                // 其他 turn 的事件（并发轮次、历史重放）一律过滤。
+                const eventTurnId = stringField(payload, "turn_id") ?? stringField(payload?.payload, "turn_id");
+                if (turnId && eventTurnId && eventTurnId !== turnId)
+                    return false;
+                seq += 1;
+                const block = normalizeDeepseekEvent(eventName, payload, seq);
+                if (block)
+                    opts.onBlock?.(block);
+                const extractedError = extractDeepseekError(eventName, payload);
+                if (extractedError)
+                    errorText = extractedError;
+                if (eventName === "message.delta") {
+                    append(stringField(payload, "content") ?? "");
+                }
+                else if (eventName === "item.delta" && isAgentMessageDelta(payload)) {
+                    append(extractDeepseekDelta(payload));
+                }
+                if (eventName === "turn.started" || embeddedDeepseekEvent(payload) === "turn.started") {
+                    opts.onStatus?.({ kind: "thinking", phase: "started", label: "Thinking" });
+                }
+                else if (eventName === "tool.started" || isToolStarted(eventName, payload)) {
+                    const label = stringField(payload, "name") ??
+                        stringField(payload?.tool, "name") ??
+                        stringField(payload?.payload?.tool, "name") ??
+                        inferDeepseekToolName(payload?.item ?? payload?.payload?.item) ??
+                        "tool";
+                    opts.onStatus?.({ kind: "thinking", phase: "updated", label });
+                }
+                else if (isDeepseekTerminalEvent(eventName, payload)) {
+                    opts.onStatus?.({ kind: "thinking", phase: "stopped" });
+                    return true;
+                }
+                return false;
+            };
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n\n")) !== -1) {
+                    const frame = parseSseFrame(buf.slice(0, idx));
+                    buf = buf.slice(idx + 2);
+                    if (!frame)
+                        continue;
+                    if (emit(frame.event, frame.data)) {
+                        await reader.cancel().catch(() => undefined);
+                        return { text: text.trim(), ...(errorText ? { error: errorText } : {}) };
+                    }
+                }
+            }
+            if (buf.trim()) {
+                const frame = parseSseFrame(buf);
+                if (frame)
+                    emit(frame.event, frame.data);
+            }
+            return { text: text.trim(), ...(errorText ? { error: errorText } : {}) };
+        };
+    }
+    async requestJson(url, init) {
+        const headers = new Headers(init.headers);
+        if (!headers.has("content-type") && init.body)
+            headers.set("content-type", "application/json");
+        const res = await this.fetchFn(url, { ...init, headers });
+        if (!res.ok) {
+            let detail = "";
+            try {
+                detail = await res.text();
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`HTTP ${res.status}${detail ? `: ${detail.slice(0, 300)}` : ""}`);
+        }
+        return (await res.json());
+    }
+}
+/** 仅测试用：清空进程池。 */
+export function __resetDeepseekTuiPoolForTests() {
+    for (const [key, handle] of PROCESS_POOL.entries()) {
+        shutdownHandle(handle, "test-reset");
+        PROCESS_POOL.delete(key);
+    }
+}
+function normalizeDeepseekEvent(eventName, payload, seq) {
+    if (eventName === "message.delta") {
+        return { raw: { event: eventName, payload }, kind: "assistant_text", seq };
+    }
+    if (eventName === "tool.started" || isToolStarted(eventName, payload)) {
+        return { raw: { event: eventName, payload }, kind: "tool_use", seq };
+    }
+    if (eventName === "tool.completed" || isToolCompleted(eventName, payload)) {
+        return { raw: { event: eventName, payload }, kind: "tool_result", seq };
+    }
+    if (eventName === "item.delta" && isAgentMessageDelta(payload)) {
+        return { raw: { event: eventName, payload }, kind: "assistant_text", seq };
+    }
+    if (eventName === "item.completed" && isAgentReasoningItem(payload)) {
+        return { raw: { event: eventName, payload }, kind: "thinking", seq };
+    }
+    if (eventName === "turn.started" ||
+        eventName === "status" ||
+        embeddedDeepseekEvent(payload) === "turn.started") {
+        return { raw: { event: eventName, payload }, kind: "system", seq };
+    }
+    if (eventName === "error" || isDeepseekTerminalEvent(eventName, payload)) {
+        return { raw: { event: eventName, payload }, kind: "other", seq };
+    }
+    return null;
+}
+function embeddedDeepseekEvent(payload) {
+    return stringField(payload, "event") ?? stringField(payload?.payload, "event");
+}
+function isDeepseekTerminalEvent(eventName, payload) {
+    const embedded = embeddedDeepseekEvent(payload);
+    return (eventName === "turn.completed" ||
+        eventName === "turn.finished" ||
+        eventName === "turn.done" ||
+        eventName === "done" ||
+        embedded === "turn.completed" ||
+        embedded === "turn.finished" ||
+        embedded === "turn.done" ||
+        embedded === "done");
+}
+function isToolStarted(eventName, payload) {
+    const itemKind = payload?.payload?.item?.kind ?? payload?.item?.kind;
+    return ((eventName === "item.started" &&
+        (!!payload?.tool ||
+            itemKind === "tool_call" ||
+            itemKind === "command_execution" ||
+            itemKind === "file_change")) ||
+        (payload?.event === "item.started" && !!payload?.payload?.tool));
+}
+function isToolCompleted(eventName, payload) {
+    const kind = payload?.payload?.item?.kind ?? payload?.item?.kind;
+    return ((eventName === "item.completed" ||
+        eventName === "item.failed" ||
+        payload?.event === "item.completed" ||
+        payload?.event === "item.failed") &&
+        (kind === "tool_call" || kind === "file_change" || kind === "command_execution"));
+}
+function isAgentMessageDelta(payload) {
+    return payload?.kind === "agent_message" || payload?.payload?.kind === "agent_message";
+}
+function isAgentReasoningItem(payload) {
+    return (payload?.item?.kind === "agent_reasoning" ||
+        payload?.payload?.item?.kind === "agent_reasoning");
+}
+function extractDeepseekDelta(payload) {
+    return stringField(payload, "delta") ?? stringField(payload?.payload, "delta") ?? "";
+}
+function inferDeepseekToolName(item) {
+    const candidates = [stringField(item, "summary"), stringField(item, "detail")];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const match = candidate.match(/^([A-Za-z0-9_.:-]+)\s*(?:started|completed|failed|returned|:)/);
+        if (match?.[1] && match[1] !== "tool_call")
+            return match[1];
+    }
+    return undefined;
+}
+function emptyCompletionError(stderrTail) {
+    const tail = stderrTail.trim();
+    if (!tail) {
+        return "deepseek runtime completed with no assistant_message (check DEEPSEEK_API_KEY / model availability)";
+    }
+    const lines = tail.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const lastLines = lines.slice(-5).join("\n").slice(-500);
+    return `deepseek runtime completed with no assistant_message; stderr tail: ${lastLines}`;
+}
+function extractDeepseekError(eventName, payload) {
+    if (eventName === "error") {
+        return (stringField(payload, "message") ??
+            stringField(payload, "error") ??
+            stringField(payload?.payload, "message") ??
+            stringField(payload?.payload, "error"));
+    }
+    if (eventName === "item.failed") {
+        return (stringField(payload?.payload?.item, "detail") ??
+            stringField(payload?.payload?.item, "summary") ??
+            stringField(payload?.payload, "error"));
+    }
+    if (isDeepseekTerminalEvent(eventName, payload)) {
+        const turn = payload?.payload?.turn ?? payload?.turn;
+        const status = stringField(turn, "status");
+        const err = stringField(turn, "error");
+        if (err)
+            return err;
+        if (status && status !== "completed")
+            return `DeepSeek turn ${status}`;
+    }
+    return undefined;
+}
+function parseSseFrame(raw) {
+    let event = "message";
+    const dataLines = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (line.startsWith("event:"))
+            event = line.slice("event:".length).trim();
+        else if (line.startsWith("data:"))
+            dataLines.push(line.slice("data:".length).trimStart());
+    }
+    if (dataLines.length === 0)
+        return null;
+    try {
+        return { event, data: JSON.parse(dataLines.join("\n")) };
+    }
+    catch {
+        return { event, data: { content: dataLines.join("\n") } };
+    }
+}
+function authHeaders(token) {
+    return token ? { authorization: `Bearer ${token}` } : {};
+}
+function parseDeepseekRuntimeSelection(extraArgs) {
+    const out = {};
+    if (!extraArgs?.length)
+        return out;
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        if (arg === "--model") {
+            const value = nextArgValue(extraArgs, i);
+            if (value !== undefined) {
+                out.model = value;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--model=")) {
+            out.model = arg.slice("--model=".length);
+        }
+        else if (arg === "--reasoning-effort") {
+            const value = nextArgValue(extraArgs, i);
+            if (value !== undefined) {
+                out.reasoningEffort = value;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--reasoning-effort=")) {
+            out.reasoningEffort = arg.slice("--reasoning-effort=".length);
+        }
+    }
+    return out;
+}
+function nextArgValue(args, index) {
+    const next = args[index + 1];
+    if (typeof next !== "string")
+        return undefined;
+    if (!next.startsWith("-"))
+        return next;
+    return /^-\d/.test(next) ? next : undefined;
+}
+function resetIdle(handle, key) {
+    if (handle.idleTimer)
+        clearTimeout(handle.idleTimer);
+    if (handle.inFlight > 0 || handle.closed)
+        return;
+    handle.idleTimer = setTimeout(() => {
+        if (handle.inFlight === 0 && !handle.closed) {
+            log.info("deepseek-tui.idle-timeout", { key });
+            shutdownHandle(handle, "idle-timeout");
+            PROCESS_POOL.delete(key);
+        }
+    }, DEEPSEEK_IDLE_TIMEOUT_MS);
+    handle.idleTimer.unref?.();
+}
+function shutdownHandle(handle, reason) {
+    if (handle.closed)
+        return;
+    handle.closed = true;
+    if (handle.idleTimer)
+        clearTimeout(handle.idleTimer);
+    try {
+        const pid = handle.child.pid;
+        if (typeof pid === "number" && pid > 0) {
+            // 负 pid 对整个进程组发信号（对应 spawn 的 detached），同时杀掉
+            // dispatcher 与它再 spawn 的 deepseek-tui server。
+            process.kill(-pid, "SIGTERM");
+        }
+        else {
+            handle.child.kill("SIGTERM");
+        }
+    }
+    catch {
+        try {
+            handle.child.kill("SIGTERM");
+        }
+        catch {
+            // no-op
+        }
+    }
+    try {
+        handle.child.stdout?.destroy();
+        handle.child.stderr?.destroy();
+        handle.child.stdin?.destroy();
+        handle.child.unref();
+    }
+    catch {
+        // no-op
+    }
+    log.debug("deepseek-tui.shutdown", { reason });
+}
+async function waitForHealth(baseUrl, fetchFn, child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError = "";
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`deepseek serve exited with code ${child.exitCode}`);
+        }
+        try {
+            const res = await fetchFn(`${baseUrl}/health`, { method: "GET" });
+            if (res.ok)
+                return;
+            lastError = `HTTP ${res.status}`;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err.message : String(err);
+        }
+        await sleep(STARTUP_POLL_MS);
+    }
+    throw new Error(`deepseek serve did not become healthy: ${lastError}`);
+}
+async function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            srv.close(() => {
+                if (typeof addr === "object" && addr?.port)
+                    resolve(addr.port);
+                else
+                    reject(new Error("failed to allocate port"));
+            });
+        });
+    });
+}
+function randomToken() {
+    return `blc_ds_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stringField(obj, key) {
+    const v = obj?.[key];
+    return typeof v === "string" ? v : undefined;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function isValidThreadId(id) {
+    return id.length > 0 && id.length <= 256 && !/[\u0000-\u001f\u007f]/.test(id);
+}
+/**
+ * PATH 上的 `deepseek` 可能是负责下载真实二进制的 dispatcher shim：
+ * realpath 后同目录 `downloads/deepseek` 存在则优先用它。
+ */
+function resolveDownloadedDeepseekBinary(onPath, deps = {}) {
+    const exists = deps.existsSyncFn ?? existsSync;
+    try {
+        const resolved = realpathSync(onPath);
+        const candidate = path.join(path.dirname(resolved), "downloads", "deepseek");
+        return exists(candidate) ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function nullChild() {
+    return {
+        kill: () => true,
+        on: () => nullChild(),
+        stderr: { setEncoding: () => undefined, on: () => undefined },
+        stdout: { setEncoding: () => undefined, on: () => undefined },
+        stdin: { write: () => true },
+        exitCode: null,
+    };
+}
+export const deepseekTuiModule = {
+    id: "deepseek-tui",
+    displayName: "DeepSeek TUI",
+    binary: "deepseek",
+    envVar: "BOTLEARN_DEEPSEEK_TUI_BIN",
+    installHint: "Install DeepSeek TUI (`deepseek` on PATH, or set BOTLEARN_DEEPSEEK_TUI_BIN). `deepseek serve` needs a logged-in account / DEEPSEEK_API_KEY to answer prompts.",
+    probe: async () => probeDeepseekTui(),
+    create: () => wrapEngineAdapter("deepseek-tui", new DeepseekTuiAdapter()),
+};