personal-bot 0.2.4 → 0.2.6

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;

package/lib/integrations/dsh/messages.js

@@ -0,0 +1,11 @@
+import { lastAssistantStreamChunk } from "@deepseek-ai/dsh-llm";
+export function finalDshAnswer(event) {
+    const { message, interrupted, stream } = event.data;
+    if (interrupted || message.content.some(block => block.type === "tool-call") || lastAssistantStreamChunk(stream, "finish")?.reason.kind !== "stop")
+        return "";
+    return message.content.filter(block => block.type === "text").map(block => block.text).join("\n");
+}
+export function requestSource(message, generation) {
+    const source = message.source;
+    return source.kind === "pbot-input" && source.generation === generation ? source : undefined;
+}

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

@@ -0,0 +1,8 @@
+import type { SessionEvent } from "@deepseek-ai/dsh-session";
+import type { UserMessage } from "@deepseek-ai/dsh-llm";
+import "./messages.js";
+/** Only committed native context or successful model tool results claim notices.
+ * PTC inner reads require their enclosing transport to have committed success. */
+export declare function deliveredDshNotices(events: readonly SessionEvent[]): Set<string>;
+/** Pending inbox entries prevent duplicate submission, but are not delivery receipts. */
+export declare function pendingDshNotices(messages: readonly UserMessage[]): string[];

package/lib/integrations/dsh/notifications.js

@@ -0,0 +1,55 @@
+import { object } from "../../common/json.js";
+import "./messages.js";
+function keys(value, field) {
+    if (!object(value))
+        return [];
+    const items = value[field];
+    return Array.isArray(items) && items.every(item => typeof item === "string") ? items : [];
+}
+/** Only committed native context or successful model tool results claim notices.
+ * PTC inner reads require their enclosing transport to have committed success. */
+export function deliveredDshNotices(events) {
+    const delivered = new Set();
+    const reads = new Set(), nested = new Map();
+    for (const event of events) {
+        if (event.type === "turn/start" || event.type === "step/start" || event.type === "turn/end") {
+            reads.clear();
+            nested.clear();
+        }
+        if (event.type === "user/message" && event.data.source.kind === "pbot-results") {
+            for (const key of keys(event.data.source, "keys"))
+                delivered.add(key);
+        }
+        if (event.type === "tool/call" && event.data.name === "pbot_agent") {
+            try {
+                const args = JSON.parse(event.data.arguments);
+                if (object(args) && args.action === "read")
+                    reads.add(event.data.callId);
+            }
+            catch { /* An invalid call cannot claim a report. */ }
+        }
+        if (event.type === "tool/ptc-dispatch" && event.data.name === "pbot_agent" && !event.data.isError &&
+            object(event.data.arguments) && event.data.arguments.action === "read") {
+            const values = nested.get(event.data.rootCallId) ?? [];
+            values.push(...keys(event.data.meta, "pbotAgentReadKeys"));
+            nested.set(event.data.rootCallId, values);
+        }
+        if (event.type === "tool/result") {
+            const message = event.data.message;
+            if (!message.isError) {
+                if (reads.has(message.toolCallId))
+                    for (const key of keys(event.data.meta, "pbotAgentReadKeys"))
+                        delivered.add(key);
+                for (const key of nested.get(message.toolCallId) ?? [])
+                    delivered.add(key);
+            }
+            reads.delete(message.toolCallId);
+            nested.delete(message.toolCallId);
+        }
+    }
+    return delivered;
+}
+/** Pending inbox entries prevent duplicate submission, but are not delivery receipts. */
+export function pendingDshNotices(messages) {
+    return messages.flatMap(message => message.source.kind === "pbot-results" ? keys(message.source, "keys") : []);
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { AgentOptions } from "../../model/agent.js";
+export declare function dshResources(ctx: Context, agent: Agent, root: string, role: "coordinator" | "general-purpose", python: () => {
+    state: string;
+    directory?: string;
+    error?: string;
+}, check: () => void): Promise<void>;
+/** Map the expert's native loadout; this is not isolation from Bash, CLI, or MCP. */
+export declare function dshExpertTools(ctx: Context, agent: Agent, options: AgentOptions): boolean;

package/lib/integrations/dsh/resources.js

@@ -0,0 +1,41 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { FileSystemSkillProvider } from "@deepseek-ai/dsh-skill-filesystem";
+import { agentText } from "../agent-resources.js";
+import { resourceRoot } from "../../common/paths.js";
+import { requireThat } from "../../common/validation.js";
+export async function dshResources(ctx, agent, root, role, python, check) {
+    let text = await agentText(role, root);
+    const workspace = await readFile(join(resourceRoot, "prompts/workspace.md"), "utf8");
+    check();
+    ctx.systemPrompt.section({ name: "pbot:role", order: 1, text: () => text, interpolate: false });
+    ctx.systemPrompt.section({ name: "pbot:workspace", order: 2, text: workspace, interpolate: false });
+    ctx.systemPrompt.context({ name: "pbot:environment", order: 300, required: true, interpolate: false,
+        text: () => JSON.stringify({ host: "dsh", workspaceRoot: root, cwd: ctx.workingDirectory.get(agent.session), resourceRoot, python: python() }) });
+    ctx.skills.registerProvider(control => new FileSystemSkillProvider(ctx, control, {
+        providerName: "pbot", includeDefaultRoots: false, customSkillDirs: [join(root, ".agents/skills")],
+        bundledSkillDir: join(resourceRoot, "skills"), watch: false,
+    }));
+    ctx.on("agent/pre-step", async (_payload, next) => {
+        check();
+        text = await agentText(role, root);
+        check();
+        return next();
+    });
+}
+/** Map the expert's native loadout; this is not isolation from Bash, CLI, or MCP. */
+export function dshExpertTools(ctx, agent, options) {
+    const names = new Set(ctx.tools.definitions(agent).map(tool => tool.name));
+    const forbidden = new Set(["pbot_agent", "pbot_team", "pbot_history", "subagent", "list_subagent_models", "list_agents", "send_message", "interrupt_agent"]);
+    if (options.noSkills)
+        forbidden.add("skill");
+    if (options.tools) {
+        for (const name of options.tools)
+            requireThat((names.has(name) || name === "pbot_team_message") && !forbidden.has(name), "专家工具不可用：" + name);
+        ctx.tools.restrict({ allow: options.tools.filter(name => name !== "pbot_team_message") });
+    }
+    const deny = [...forbidden].filter(name => names.has(name));
+    if (deny.length)
+        ctx.tools.restrict({ deny });
+    return !options.tools || options.tools.includes("pbot_team_message");
+}

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

@@ -0,0 +1,7 @@
+import type { TSchema } from "typebox";
+import type { JsonSchemaNode } from "@deepseek-ai/dsh-tools";
+/** Remove TypeBox's non-JSON metadata before passing a schema to the native host. */
+export declare function dshParameters(value: TSchema): Record<string, unknown>;
+/** Collaboration result unions are disjoint. rc.1 enforces structural oneOf schemas;
+ * the producing tool also validates the complete contract, including these bounds. */
+export declare function dshOutputSchema(value: TSchema): JsonSchemaNode;

package/lib/integrations/dsh/schema.js

@@ -0,0 +1,28 @@
+import { requireThat } from "../../common/validation.js";
+/** Remove TypeBox's non-JSON metadata before passing a schema to the native host. */
+export function dshParameters(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/** Collaboration result unions are disjoint. rc.1 enforces structural oneOf schemas;
+ * the producing tool also validates the complete contract, including these bounds. */
+export function dshOutputSchema(value) {
+    const bounds = new Set(["minLength", "maxLength", "pattern", "minimum", "maximum", "minItems", "maxItems"]);
+    const supported = new Set(["type", "required", "additionalProperties", "enum", "const", "description", "title", "default", "examples"]);
+    function convert(node) {
+        const result = {};
+        for (const [key, item] of Object.entries(node)) {
+            if (key === "anyOf")
+                result.oneOf = item.map(convert);
+            else if (key === "properties")
+                result.properties = Object.fromEntries(Object.entries(item).map(([name, child]) => [name, convert(child)]));
+            else if (key === "items")
+                result.items = convert(item);
+            else if (!bounds.has(key)) {
+                requireThat(supported.has(key), "dsh 输出 schema 不支持字段：" + key);
+                result[key] = item;
+            }
+        }
+        return result;
+    }
+    return convert(dshParameters(value));
+}

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

@@ -0,0 +1,14 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, AgentHandle, AgentSetup } from "@deepseek-ai/dsh-agent";
+import type { SessionHeader } from "@deepseek-ai/dsh-session";
+import type { AgentDescriptor } from "../../model/agent.js";
+/** Read access must neither claim a writer nor activate an Agent. */
+export declare function readDshAgentSession(ctx: Context, d: AgentDescriptor): Promise<{
+    header: SessionHeader;
+    events: readonly import("@deepseek-ai/dsh-session").SessionEvent[];
+}>;
+/** An empty Agent is not recoverable until this native barrier has materialized it. */
+export declare function flushDshAgent(agent: Agent): Promise<void>;
+export declare function openDshAgent(ctx: Context, d: AgentDescriptor, parent: Agent, resume: boolean, setup: AgentSetup, signal: AbortSignal): Promise<AgentHandle>;
+/** A report refers to one durable turn boundary, never the latest answer. */
+export declare function readDshReport(ctx: Context, d: AgentDescriptor, reference: string): Promise<string>;