personal-bot 0.2.3 → 0.2.5

package/lib/extension/setup-cli.js

@@ -0,0 +1,136 @@
+import { mkdir, readFile, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { executeSetup, packageChoices, parseCatalog, parseSetupArgs } from "../services/installation/setup-service.js";
+import { npmName, ordinaryNpm } from "../common/package-source.js";
+import { PiBootstrapRequired, PiSetup, piPackageName } from "../integrations/installation/pi-setup.js";
+import { inspectSystem, SetupProcesses } from "../integrations/installation/processes.js";
+import { resolveWorkspace } from "../integrations/installation/workspace.js";
+import { SetupUI } from "../ui/setup.js";
+const root = new URL("../../", import.meta.url);
+const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+export async function main(args) {
+    let options;
+    try {
+        options = parseSetupArgs(args);
+    }
+    catch (error) {
+        console.error(String(error));
+        return 2;
+    }
+    const manifest = JSON.parse(await readFile(new URL("package.json", root), "utf8"));
+    if (options.action === "version") {
+        console.log(manifest.version);
+        return 0;
+    }
+    if (options.action === "help") {
+        console.log("Personal Bot " + manifest.version + "\n\n用法：pbot setup [--workspace <目录>]\n" +
+            "      npx personal-bot@latest setup\n\nsetup 安装或升级 Pi、pbot 和选中的插件，然后启动 Pi 执行 /pbot init。\n" +
+            "支持 Linux/macOS，需要 Node.js 22.19+、npm 和 Python 3.11+。\n--help 显示帮助；--version 显示安装器版本。");
+        return 0;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error("setup 需要交互终端。请在终端运行 npx personal-bot@latest setup。");
+        return 2;
+    }
+    const controller = new AbortController();
+    const cancel = () => controller.abort(new Error("安装已取消；已完成的步骤保留。"));
+    process.on("SIGINT", cancel);
+    process.on("SIGTERM", cancel);
+    const ui = new SetupUI(controller), processes = new SetupProcesses(controller.signal);
+    try {
+        const cwd = process.cwd();
+        ui.text("Personal Bot " + manifest.version + " — 安装与升级\n正在检查 Node/npm、Python 和 tmux…");
+        const system = await inspectSystem(processes, cwd);
+        const supplied = options.workspace ?? await ui.ask("工作区目录（当前、已有或新建目录）", cwd);
+        const workspace = await resolveWorkspace(supplied, cwd, homedir());
+        const host = new PiSetup(processes, system.npm, cwd);
+        let pi = await host.inspectPi();
+        let installed;
+        try {
+            installed = await host.inspectPackages(pi, workspace);
+        }
+        catch (error) {
+            if (!(error instanceof PiBootstrapRequired))
+                throw error;
+            const version = await host.latest(piPackageName);
+            ui.text(error.message + "\n需先安装 Pi 才能使用其原生接口核对这些来源。目标版本：" + version);
+            if (!await ui.confirm("先通过 npm 安装 Pi，再继续选择工作区插件"))
+                return 130;
+            pi = await host.ensurePi(undefined, version);
+            installed = await host.inspectPackages(pi, workspace);
+        }
+        const catalog = parseCatalog(JSON.parse(await readFile(new URL("resources/installer/plugins.json", root), "utf8")));
+        const choices = packageChoices(catalog, installed), optional = choices.filter(choice => !choice.required);
+        ui.text("\nPersonal Bot 必装。选择配套插件（取消勾选不会卸载已有插件）：");
+        const selected = await ui.selectMany(optional.map(choice => choice.plugin.label + " — " + choice.plugin.description), optional.flatMap((choice, index) => choice.selected ? [index] : []));
+        optional.forEach((choice, index) => { choice.selected = selected.includes(index); });
+        for (const choice of choices.filter(item => item.selected)) {
+            if (choice.existing.some(pkg => !ordinaryNpm(pkg.source))) {
+                ui.text("\n" + choice.plugin.label + " 的已有来源：\n" + choice.existing.map(pkg => "  " + pkg.scope + ": " + pkg.source + " (" + (pkg.version ?? "版本未知") + ")").join("\n"));
+                choice.keep = !await ui.confirm("切换到 npm 最新稳定版", false);
+            }
+            if (choice.keep) {
+                if (choice.existing.length !== 1 || !choice.existing[0]?.installedPath)
+                    choice.error = "保留来源未安装或存在多份来源，请先通过 Pi 原生配置处理。";
+            }
+            else {
+                const others = choice.existing.filter(pkg => !npmName(pkg.source));
+                if (others.length > 1 || others.some(pkg => pkg.scope === "user")) {
+                    choice.error = "请先用 pi config 调整全局或重复来源的加载范围，再切换到 npm。";
+                }
+                else {
+                    try {
+                        choice.target = await host.latest(npmName(choice.plugin.source));
+                    }
+                    catch (error) {
+                        controller.signal.throwIfAborted();
+                        choice.error = String(error);
+                    }
+                }
+            }
+        }
+        const plan = { workspace, piVersion: await host.latest(piPackageName), packages: choices,
+            ...(pi ? { pi } : {}), ...(system.tmux ? { tmux: system.tmux } : {}) };
+        ui.text("\n安装计划\n工作区：" + workspace + "\nPi：" + (pi ? pi.command + " (" + pi.version + ")" : "通过 npm 全局安装") + " → " + plan.piVersion);
+        if (system.tmux)
+            ui.text("tmux：" + [system.tmux.command, ...system.tmux.args].map(quote).join(" "));
+        for (const choice of choices) {
+            ui.text("  " + choice.plugin.label + ": " + (!choice.selected ? "本次跳过" : choice.error ??
+                (choice.keep ? "保留 " + choice.existing[0]?.source : (choice.existing.map(pkg => pkg.version ?? "未知").join(", ") || "未安装") + " → " + choice.target)));
+            if (choice.selected && choice.existing.some(pkg => pkg.filtered))
+                ui.text("    保留已有资源过滤；如 pbot 被禁用，请通过 pi config --local 启用。");
+        }
+        const blocking = choices.find(choice => choice.required && choice.error);
+        if (blocking)
+            throw new Error(blocking.error);
+        ui.text("升级前请停止活动 pbot 子会话和相关 Python 脚本。Pi 为当前用户共用，插件只处理此工作区。");
+        if (!await ui.confirm("执行以上计划"))
+            return 130;
+        await mkdir(workspace, { recursive: true });
+        if (await realpath(workspace) !== workspace)
+            throw new Error("工作区路径已发生变化，请重新运行 setup。");
+        const result = await executeSetup(plan, host, item => ui.text("[" + item.state + "] " + item.name + ": " + item.detail), controller.signal);
+        const failed = result.results.some(item => item.state === "failed");
+        if (!result.pi)
+            return 1;
+        ui.text("\n软件安装阶段结束。初始化、Python 环境和外部服务的状态由 Pi/pbot/插件分别报告。");
+        if (await ui.confirm(failed ? "部分插件失败，是否仍先启动 Pi" : "立即启动 Pi", !failed)) {
+            process.stdin.pause();
+            await host.start(result.pi, workspace);
+        }
+        else {
+            ui.text("稍后执行：\ncd " + quote(workspace) + "\n" + quote(result.pi.command) + " --extension " +
+                quote(fileURLToPath(new URL("extension/setup-guard.js", new URL("../", import.meta.url)))) + " '/pbot init'");
+        }
+        return failed ? 1 : 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return controller.signal.aborted ? 130 : 1;
+    }
+    finally {
+        process.off("SIGINT", cancel);
+        process.off("SIGTERM", cancel);
+    }
+}

package/lib/extension/setup-guard.js

@@ -0,0 +1,11 @@
+// Native extension commands run before input handlers. Reaching this handler for
+// /pbot init means it was not dispatched; never let the setup input reach a model.
+export default function setupGuard(pi) {
+    pi.on("input", (event, ctx) => {
+        if (event.text.trim() !== "/pbot init")
+            return { action: "continue" };
+        ctx.ui.notify("pbot 未加载或命令存在冲突。请检查项目信任和 pi config --local 后重新运行 setup。", "error");
+        ctx.shutdown();
+        return { action: "handled" };
+    });
+}

package/lib/integrations/agent-resources.d.ts

@@ -0,0 +1 @@
+export declare function agentText(agent: "coordinator" | "general-purpose", root: string): Promise<string>;

package/lib/integrations/agent-resources.js

@@ -0,0 +1,18 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resourceRoot } from "../common/paths.js";
+import { requireThat } from "../common/validation.js";
+export async function agentText(agent, root) {
+    requireThat(agent === "coordinator" || agent === "general-purpose", "未知职责。");
+    let text = await readFile(join(resourceRoot, "agents", agent + ".md"), "utf8");
+    try {
+        const local = await readFile(join(root, "agents", agent + ".md"), "utf8");
+        text += "\n\n工作区职责补充：\n" + local;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    requireThat(text.trim(), "专家职责为空。");
+    return text;
+}

package/lib/integrations/dsh/dsh-agents.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, AgentSetup } from "@deepseek-ai/dsh-agent";
+import type { AgentDescriptor, AgentSessionReference } from "../../model/agent.js";
+import type { AgentHost } from "../../services/agents/agent-service.js";
+/** Native handles belong to the execution component, independently of browser observers. */
+export declare class DshAgents implements AgentHost {
+    #private;
+    readonly ctx: Context;
+    readonly parent: Agent;
+    readonly composition: {
+        setup(d: AgentDescriptor, directory: string, generation: string): AgentSetup;
+        ready(agent: Agent, generation: string): void;
+        stopping(agent: Agent, generation: string): Promise<void>;
+    };
+    readonly lifetime: AbortSignal;
+    readonly kind = "dsh";
+    constructor(ctx: Context, parent: Agent, composition: {
+        setup(d: AgentDescriptor, directory: string, generation: string): AgentSetup;
+        ready(agent: Agent, generation: string): void;
+        stopping(agent: Agent, generation: string): Promise<void>;
+    }, lifetime: AbortSignal);
+    available(): void;
+    alive(id: string): boolean;
+    private reference;
+    validateSession(d: AgentDescriptor, reference: AgentSessionReference): Promise<void>;
+    launch(d: AgentDescriptor, directory: string, generation: string, reference: AgentSessionReference, resume: boolean, signal: AbortSignal): Promise<void>;
+    release(id: string, generation: string): Promise<void>;
+    report(d: AgentDescriptor, reference: AgentSessionReference, position: string): Promise<string>;
+    close(): Promise<void>;
+}

package/lib/integrations/dsh/dsh-agents.js

@@ -0,0 +1,104 @@
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { requireThat } from "../../common/validation.js";
+import { openDshAgent, readDshAgentSession, readDshReport } from "./session.js";
+/** Native handles belong to the execution component, independently of browser observers. */
+export class DshAgents {
+    ctx;
+    parent;
+    composition;
+    lifetime;
+    kind = "dsh";
+    #runs = new Map();
+    #closed = false;
+    constructor(ctx, parent, composition, lifetime) {
+        this.ctx = ctx;
+        this.parent = parent;
+        this.composition = composition;
+        this.lifetime = lifetime;
+    }
+    available() {
+        this.lifetime.throwIfAborted();
+        requireThat(!this.#closed && this.ctx.agents.get(this.parent.id) === this.parent, "dsh 父会话或执行组件已关闭。");
+    }
+    alive(id) {
+        const run = this.#runs.get(id);
+        return Boolean(this.ctx.agents.get(SessionId(id))) || Boolean(run && (run.closing || !run.handle));
+    }
+    reference(d, reference) {
+        requireThat(reference.host === "dsh" && reference.sessionId === d.agentId, "不能接管其他宿主或其他身份的原生会话。");
+    }
+    async validateSession(d, reference) {
+        this.available();
+        this.reference(d, reference);
+        requireThat(!this.alive(d.agentId), "原生专家仍被占用，不能恢复。");
+        await readDshAgentSession(this.ctx, d);
+        requireThat(!this.alive(d.agentId), "原生专家仍被占用，不能恢复。");
+    }
+    async launch(d, directory, generation, reference, resume, signal) {
+        this.available();
+        this.reference(d, reference);
+        requireThat(!this.alive(d.agentId), "dsh 专家仍在运行或释放中。");
+        const previous = this.#runs.get(d.agentId);
+        if (previous)
+            await this.release(d.agentId, previous.generation);
+        signal.throwIfAborted();
+        this.available();
+        const controller = new AbortController();
+        const combined = AbortSignal.any([signal, this.lifetime, controller.signal]);
+        const opening = Promise.resolve().then(() => openDshAgent(this.ctx, d, this.parent, resume, this.composition.setup(d, directory, generation), combined));
+        const run = { generation, controller, opening };
+        this.#runs.set(d.agentId, run);
+        try {
+            run.handle = await opening;
+            if (combined.aborted) {
+                await this.release(d.agentId, generation);
+                combined.throwIfAborted();
+            }
+            this.composition.ready(run.handle.agent, generation);
+        }
+        catch (error) {
+            if (!run.handle && this.#runs.get(d.agentId) === run)
+                this.#runs.delete(d.agentId);
+            throw error;
+        }
+    }
+    release(id, generation) {
+        const run = this.#runs.get(id);
+        if (!run)
+            return this.ctx.agents.get(SessionId(id)) ? Promise.reject(new Error("原生专家仍由其他执行实例持有；当前组件不能释放。")) : Promise.resolve();
+        if (run.generation !== generation)
+            return Promise.resolve();
+        if (run.closing)
+            return run.closing;
+        run.controller.abort();
+        run.closing = (async () => {
+            const handle = run.handle ?? await run.opening.catch(() => undefined);
+            let failure;
+            if (handle) {
+                try {
+                    await this.composition.stopping(handle.agent, generation);
+                }
+                catch (error) {
+                    failure = error;
+                }
+                await handle.dispose();
+            }
+            if (this.#runs.get(id) === run)
+                this.#runs.delete(id);
+            if (failure)
+                throw failure;
+        })();
+        return run.closing;
+    }
+    report(d, reference, position) {
+        this.reference(d, reference);
+        return readDshReport(this.ctx, d, position);
+    }
+    async close() {
+        this.#closed = true;
+        const results = await Promise.allSettled([...this.#runs].map(([id, run]) => this.release(id, run.generation)));
+        const errors = results.flatMap(r => r.status === "rejected" ? [r.reason] : []);
+        if (errors.length)
+            throw new AggregateError(errors, "dsh 专家仍有未释放的执行资源。");
+    }
+}

package/lib/integrations/dsh/history-summary.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { HistorySummarizer } from "../../model/history.js";
+declare module "@deepseek-ai/dsh-llm" {
+    interface LlmRequestPurposeMap {
+        "pbot-history": true;
+    }
+}
+/** Independent text calls through the host's routing and authentication; no Agent or Session messages. */
+export declare function dshHistorySummarizer(ctx: Context, selection: ReturnType<Agent["model"]["current"]>, sessionId: SessionId): HistorySummarizer;

package/lib/integrations/dsh/history-summary.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { BlockAssembler } from "@deepseek-ai/dsh-llm";
+import { resourceRoot } from "../../common/paths.js";
+import { requireThat } from "../../common/validation.js";
+import { reduceHistorySummary } from "../history-summary.js";
+/** Independent text calls through the host's routing and authentication; no Agent or Session messages. */
+export function dshHistorySummarizer(ctx, selection, sessionId) {
+    return async (text, signal) => {
+        requireThat(selection, "请先选择 dsh 模型。");
+        signal.throwIfAborted();
+        const system = await readFile(join(resourceRoot, "prompts/history-summary.md"), { encoding: "utf8", signal });
+        const prepare = () => ctx.llm.prepareCall({ provider: selection.provider, model: selection.model, maxTokens: 2048 }, signal, (controls, model) => ({ ...controls, ...(model.reasoning?.efforts[0] ? { reasoningEffort: model.reasoning.efforts[0].id } : {}) }));
+        let first = await prepare();
+        const budget = Math.max(2000, Math.min(24000, Math.floor((first.context?.contextWindow ?? 12000) / 2)));
+        const ask = async (content, signal) => {
+            signal.throwIfAborted();
+            const prepared = first ?? await prepare();
+            first = undefined;
+            const assembler = new BlockAssembler();
+            let finished = false;
+            for await (const chunk of prepared.stream({ ...prepared.config, system, sessionId, purpose: "pbot-history", signal, tools: [],
+                messages: [{ role: "user", content: [{ type: "text", text: content }] }] })) {
+                signal.throwIfAborted();
+                assembler.push(chunk);
+                if (chunk.type === "finish")
+                    finished = true;
+            }
+            signal.throwIfAborted();
+            const reason = assembler.finish;
+            requireThat(finished && reason.kind === "stop", reason.kind === "error" || reason.kind === "aborted" ? reason.failure.message : "历史摘要未正常结束：" + reason.kind);
+            const blocks = assembler.blocks();
+            requireThat(!blocks.some(block => block.type === "tool-call"), "历史摘要不能执行工具。");
+            const answer = blocks.filter(block => block.type === "text").map(block => block.text).join("\n").trim();
+            requireThat(answer, "历史摘要为空。");
+            return answer;
+        };
+        return reduceHistorySummary(budget, ask)(text, signal);
+    };
+}

package/lib/integrations/dsh/history.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { SessionEvent, SessionHeader } from "@deepseek-ai/dsh-session";
+import type { HistoryLocation, HistorySession, HistorySource } from "../../model/history.js";
+/** Archive questions and the final/partial answer; raw tool records stay in the native log. */
+export declare function projectDshHistory(header: SessionHeader, events: readonly SessionEvent[], name?: string): HistorySession;
+export declare class DshHistory implements HistorySource {
+    private readonly ctx;
+    private readonly root;
+    private readonly relatedSessions;
+    readonly host = "dsh";
+    constructor(ctx: Context, root: string, relatedSessions?: () => string[]);
+    scan(location: HistoryLocation, signal?: AbortSignal): Promise<{
+        sessions: HistorySession[];
+        warnings: string[];
+    }>;
+}

package/lib/integrations/dsh/history.js

@@ -0,0 +1,156 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { realpath } from "node:fs/promises";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { requireThat } from "../../common/validation.js";
+import { finalDshAnswer } from "./messages.js";
+const text = (content) => content.flatMap(block => block.type === "text" ? [block.text] :
+    block.type === "image" ? ["[图片 " + (block.attachment.name ?? block.attachment.attachmentId) + "]"] :
+        block.type === "file" ? ["[附件 " + (block.attachment.name ?? block.attachment.attachmentId) + "]"] : []).join("\n");
+/** Archive questions and the final/partial answer; raw tool records stay in the native log. */
+export function projectDshHistory(header, events, name = "") {
+    const exchanges = [];
+    let users = [], answer;
+    const finish = (completed = false) => {
+        if (users.length) {
+            const entries = [...users, ...(answer ? [answer] : [])];
+            const body = answer ? answer.data.message.content.filter(block => block.type === "text").map(block => block.text).join("\n") : "";
+            exchanges.push({ entryIds: entries.map(event => "dsh:" + event.seq), from: new Date(users[0].time).toISOString(),
+                to: new Date(entries.at(-1).time).toISOString(),
+                completed: completed && Boolean(answer && finalDshAnswer(answer).trim()),
+                text: users.map(event => (event.data.source.kind === "user" ? "用户：\n" : "协调者要求：\n") + text(event.data.content)).join("\n\n") +
+                    (body ? "\n\n助手：\n" + body : "") });
+        }
+        users = [];
+        answer = undefined;
+    };
+    for (const event of events) {
+        if (event.type === "turn/start")
+            finish();
+        else if (event.type === "user/message" && ["user", "pbot-input"].includes(event.data.source.kind))
+            users.push(event);
+        else if (event.type === "assistant/message" && users.length)
+            answer = event;
+        else if (event.type === "turn/end")
+            finish(event.data.reason.kind === "completed");
+    }
+    finish();
+    return { sessionId: header.id, name: name || exchanges[0]?.text.replace(/\s+/g, " ").slice(0, 80) || "",
+        branches: exchanges.length ? [exchanges] : [] };
+}
+export class DshHistory {
+    ctx;
+    root;
+    relatedSessions;
+    host = "dsh";
+    constructor(ctx, root, relatedSessions = () => []) {
+        this.ctx = ctx;
+        this.root = root;
+        this.relatedSessions = relatedSessions;
+    }
+    async scan(location, signal) {
+        requireThat(location.host === "dsh", "dsh 历史只读取 dsh 原生会话。");
+        signal?.throwIfAborted();
+        const records = await this.ctx.sessionQuery.listSessions(signal), selected = new Set(), warnings = [];
+        try {
+            for (const id of this.relatedSessions())
+                selected.add(id);
+        }
+        catch (error) {
+            warnings.push("专家引用：" + String(error));
+        }
+        if (location.sessionId)
+            selected.add(location.sessionId);
+        for (const record of records) {
+            signal?.throwIfAborted();
+            if ((record.header.origin !== "subagent" || !record.header.parentSession) && record.header.cwd &&
+                await realpath(record.header.cwd).catch(() => record.header.cwd) === this.root)
+                selected.add(record.header.id);
+        }
+        // Native subagents may use a different cwd while still belonging to a workspace's parent.
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const record of records)
+                if (record.header.origin === "subagent" && record.header.parentSession && selected.has(record.header.parentSession) && !selected.has(record.header.id)) {
+                    selected.add(record.header.id);
+                    changed = true;
+                }
+        }
+        const sessions = [];
+        for (const id of selected) {
+            signal?.throwIfAborted();
+            try {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const observation = __addDisposableResource(env_1, await this.ctx.sessionQuery.observeSession(SessionId(id), { ...(signal ? { signal } : {}), projectionMode: "none" }), false);
+                    const title = await this.ctx.sessionQuery.readTitle(SessionId(id), signal);
+                    const session = projectDshHistory(observation.header, observation.events, title?.title);
+                    if (session.branches.length)
+                        sessions.push(session);
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                warnings.push(id + ": " + String(error));
+            }
+        }
+        return { sessions, warnings };
+    }
+}

package/lib/integrations/dsh/input.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { type FileBlock, type ImageBlock } from "@deepseek-ai/dsh-llm";
+import type { AgentDescriptor, AgentMessage } from "../../model/agent.js";
+import "./messages.js";
+export declare function dshInput(ctx: Context, d: AgentDescriptor, request: AgentMessage, signal: AbortSignal): Promise<{
+    content: import("@deepseek-ai/dsh-attachment").AdmittedPromptContentPart[];
+    source: {
+        kind: "pbot-input";
+        form: "relay";
+        requestId: string;
+        generation: string;
+        parentSessionId: string;
+    };
+} & Pick<import("@deepseek-ai/dsh-llm").UserMessage, "role" | "id">>;
+/** Command attachments have already passed native upload admission; the caller never supplies arbitrary references. */
+export declare function dshHumanInput(ctx: Context, cwd: string, text: string, files: readonly string[], attachments: readonly (ImageBlock | FileBlock)[], signal: AbortSignal): Promise<{
+    content: import("@deepseek-ai/dsh-attachment").AdmittedPromptContentPart[];
+    source: {
+        kind: "user";
+    };
+} & Pick<import("@deepseek-ai/dsh-llm").UserMessage, "role" | "id">>;

package/lib/integrations/dsh/input.js

@@ -0,0 +1,62 @@
+import { basename, extname } from "node:path";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { requireThat } from "../../common/validation.js";
+import "./messages.js";
+const imageTypes = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif" };
+/** Native file attachments remain verbatim; image admission uses the host's policy. */
+async function contentFor(ctx, cwd, message, files, signal) {
+    const content = [];
+    let imageCount = 0, imageBytes = 0;
+    for (const path of files) {
+        signal.throwIfAborted();
+        const target = await ctx.fs.resolve(path, { cwd, signal });
+        const before = await ctx.fs.stat(target, signal);
+        requireThat(before?.type === "file", "附件必须是普通文件：" + path);
+        const name = basename(path), mediaType = imageTypes[extname(path).toLowerCase()];
+        if (mediaType) {
+            const limits = ctx.attachments.imageLimits;
+            requireThat(++imageCount <= limits.maxImagesPerMessage &&
+                (before.size === undefined || imageBytes + before.size <= limits.maxMessageImageBytes), "图片附件超过宿主消息准入上限。");
+            const data = await ctx.fs.readBytes(target, signal, limits.maxImageBytes);
+            imageBytes += data.byteLength;
+            requireThat(imageBytes <= limits.maxMessageImageBytes, "图片附件超过宿主消息准入上限。");
+            content.push({ type: "image", mediaType, name, data: Buffer.from(data).toString("base64") });
+        }
+        else {
+            async function* bytes(file) {
+                let offset = 0;
+                for (;;) {
+                    signal.throwIfAborted();
+                    const chunk = await ctx.fs.readByteRange(file, { offset, length: 256 * 1024 }, signal);
+                    if (!chunk.length)
+                        break;
+                    yield chunk;
+                    offset += chunk.length;
+                }
+                requireThat((await ctx.fs.stat(file, signal))?.version === before?.version, "读取期间附件已变化：" + path);
+            }
+            content.push({ type: "file", attachment: await ctx.attachments.saveFileStream({ data: bytes(target), name, signal }) });
+        }
+        requireThat((await ctx.fs.stat(target, signal))?.version === before.version, "读取期间附件已变化：" + path);
+        content.push({ type: "text", text: "附件原始路径：" + JSON.stringify(path) + "。原生附件保留本次文件内容；需要查看时使用宿主提供的附件路径。" });
+    }
+    content.push({ type: "text", text: message || "请处理所附文件。" });
+    const admitted = await ctx.attachments.admitPromptContent(content);
+    signal.throwIfAborted();
+    return admitted;
+}
+export async function dshInput(ctx, d, request, signal) {
+    const content = await contentFor(ctx, d.cwd, request.message, request.files, signal);
+    return createUserMessage({ content, source: { kind: "pbot-input", form: "relay",
+            requestId: request.requestId, generation: request.generation, parentSessionId: d.parentSessionId } });
+}
+/** Command attachments have already passed native upload admission; the caller never supplies arbitrary references. */
+export async function dshHumanInput(ctx, cwd, text, files, attachments, signal) {
+    requireThat(files.length + attachments.length <= 32, "一次最多附加 32 个文件。");
+    requireThat(!files.length || !attachments.length, "一次对话请选择服务器文件或输入框附件，不能同时使用。");
+    signal.throwIfAborted();
+    const content = attachments.length ? [...attachments, { type: "text", text: text || "请处理所附文件。" }] :
+        await contentFor(ctx, cwd, text, files, signal);
+    signal.throwIfAborted();
+    return createUserMessage({ content, source: { kind: "user" } });
+}

package/lib/integrations/dsh/messages.d.ts

@@ -0,0 +1,36 @@
+import { type UserMessage } from "@deepseek-ai/dsh-llm";
+import type { SessionEvent } from "@deepseek-ai/dsh-session";
+/** Producer metadata travels with native messages and never grants task authorization. */
+declare module "@deepseek-ai/dsh-llm" {
+    interface MessageSourceMap {
+        "pbot-input": {
+            kind: "pbot-input";
+            form: "relay";
+            requestId: string;
+            generation: string;
+            parentSessionId: string;
+        };
+        "pbot-team-context": {
+            kind: "pbot-team-context";
+            form: "relay";
+            teamId: string;
+            seqs: number[];
+        };
+        "pbot-results": {
+            kind: "pbot-results";
+            form: "notice";
+            summary: string;
+            keys: string[];
+        };
+    }
+}
+export declare function finalDshAnswer(event: Extract<SessionEvent, {
+    type: "assistant/message";
+}>): string;
+export declare function requestSource(message: UserMessage, generation: string): {
+    kind: "pbot-input";
+    form: "relay";
+    requestId: string;
+    generation: string;
+    parentSessionId: string;
+} | undefined;