personal-bot 0.2.3 → 0.2.5

package/lib/tools/teams/actions.js

@@ -0,0 +1,38 @@
+import { teamMessagesMarkdown } from "../../integrations/team-context.js";
+import { markdownResult, result } from "../result.js";
+export function executeTeam(service, agents, input, owner) {
+    const views = agents.list(owner);
+    service.recover(owner);
+    let id = input.teamId;
+    switch (input.action) {
+        case "create":
+            id = service.create(owner, { name: input.name, brief: input.brief, members: input.members }, views).teamId;
+            break;
+        case "list": return markdownResult({ teams: service.list(owner, views) }, "团队列表");
+        case "read": {
+            const page = service.read(id, { kind: "coordinator", owner }, input);
+            return result(page, false, teamMessagesMarkdown(page));
+        }
+        case "run":
+            service.run(id, owner, { instruction: input.instruction, mode: input.mode,
+                ...(input.rounds === undefined ? {} : { rounds: input.rounds }),
+                ...(input.maxConcurrent === undefined ? {} : { maxConcurrent: input.maxConcurrent }),
+                ...(input.timeoutSeconds === undefined ? {} : { timeoutSeconds: input.timeoutSeconds }) }, views);
+            break;
+        case "pause":
+            service.pause(id, owner);
+            break;
+        case "close":
+            service.close(id, owner, views);
+            break;
+    }
+    return markdownResult(service.status(id, owner, views), "团队状态");
+}
+export function executeTeamMessage(service, input, actor, requestId) {
+    if (input.action === "read") {
+        const page = service.read(input.teamId, actor, input);
+        return result(page, false, teamMessagesMarkdown(page));
+    }
+    const message = service.post(input.teamId, actor, requestId, input.text, input.replyTo);
+    return markdownResult({ teamId: input.teamId, seq: message.seq, status: "stored" }, "团队消息已保存");
+}

package/lib/tools/teams/contract.d.ts

@@ -0,0 +1,232 @@
+import { Type } from "typebox";
+export declare const teamDescription = "\u4E3B\u4F1A\u8BDD\u7BA1\u7406\u56FA\u5B9A\u6210\u5458\u56E2\u961F\u3002create \u4E0D\u542F\u52A8\u6A21\u578B\uFF1Brun \u5F00\u5C55\u6709\u9650 roundRobin \u8F6E\u6D41\u8BA8\u8BBA\u6216 parallel \u5E76\u884C\u8F6E\u6B21\uFF0C\u9ED8\u8BA4 2 \u8F6E\u3001\u6574\u6279 15 \u5206\u949F\uFF0C\u6210\u5458\u76F4\u63A5\u53D6\u5F97\u516C\u5171\u539F\u6587\u3002\u56E2\u961F\u8FD0\u884C\u65F6\u5360\u7528\u6210\u5458\uFF1Bpause \u505C\u6B62\u65B0\u5B89\u6392\u548C\u9886\u53D6\uFF0C\u5141\u8BB8\u5728\u9014\u5DE5\u4F5C\u6536\u5C3E\uFF0C\u4E4B\u540E\u53EF\u79C1\u4EBA send\uFF1B\u9700\u8981\u4E2D\u6B62\u6210\u5458\u7528 pbot_agent stop\u3002\u5230\u671F\u65F6\u5B50\u5165\u53E3\u5C3D\u529B\u4E2D\u6B62\u672A\u88AB\u4EBA\u5DE5\u63A5\u7BA1\u7684\u56E2\u961F\u5DE5\u4F5C\u3002close \u4FDD\u7559\u6210\u5458\u4F1A\u8BDD\u548C\u5386\u53F2\uFF1B\u6362\u6210\u5458\u987B\u5173\u95ED\u65E7\u56E2\u961F\u518D\u521B\u5EFA\u3002\u7EE7\u7EED\u987B\u660E\u786E run \u65B0\u6279\u6B21\uFF0C\u4E0D\u91CD\u653E\u65E7\u8BF7\u6C42\u3002\u5B8C\u6210\u4ECD\u9700\u4E1A\u52A1\u9A8C\u6536\u3002";
+export declare const teamMessageDescription = "\u76F4\u63A5\u8BFB\u53D6/\u53D1\u5E03\u56E2\u961F\u516C\u5171\u539F\u6587\u3002post \u4E0D\u5524\u9192\u6A21\u578B\u3001\u4E0D\u589E\u52A0\u8F6E\u6B21\uFF0C\u6240\u6709\u6210\u5458\u53EF\u89C1\uFF0C\u4E0D\u63D0\u4F9B\u79C1\u4FE1\u6216\u9012\u5F52\u59D4\u6D3E\u3002\u6210\u5458\u53EA\u80FD\u5728\u81EA\u5DF1\u7684\u56E2\u961F\u5DE5\u4F5C\u4E2D post\u3002read \u7528 afterSeq \u5206\u9875\uFF1B\u957F\u6D88\u606F\u7528 seq/offset/limit \u7EE7\u7EED\uFF0CnextOffset \u975E\u7A7A\u8868\u793A\u8BE5\u6761\u6B63\u6587\u4E0D\u5B8C\u6574\u3002\u4FDD\u5B58\u6210\u529F\u4E0D\u662F\u6A21\u578B\u5DF2\u8BFB\u6216\u4E1A\u52A1\u5B8C\u6210\u3002";
+export declare const teamParametersSchema: Type.TObject<{
+    afterSeq: Type.TOptional<Type.TInteger>;
+    seq: Type.TOptional<Type.TInteger>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    action: Type.TUnion<Type.TLiteral<string>[]>;
+    teamId: Type.TOptional<Type.TString>;
+    name: Type.TOptional<Type.TString>;
+    brief: Type.TOptional<Type.TString>;
+    members: Type.TOptional<Type.TArray<Type.TObject<{
+        agentId: Type.TString;
+        role: Type.TString;
+    }>>>;
+    instruction: Type.TOptional<Type.TString>;
+    mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"roundRobin">, Type.TLiteral<"parallel">]>>;
+    rounds: Type.TOptional<Type.TInteger>;
+    maxConcurrent: Type.TOptional<Type.TInteger>;
+    timeoutSeconds: Type.TOptional<Type.TInteger>;
+}>;
+export declare const teamActionSchema: Type.TUnion<[Type.TObject<{
+    action: Type.TLiteral<"create">;
+    name: Type.TString;
+    brief: Type.TString;
+    members: Type.TArray<Type.TObject<{
+        agentId: Type.TString;
+        role: Type.TString;
+    }>>;
+}>, Type.TObject<{
+    action: Type.TLiteral<"list">;
+}>, ...Type.TObject<{
+    action: Type.TLiteral<string>;
+    teamId: Type.TString;
+}>[], Type.TObject<{
+    instruction: Type.TString;
+    mode: Type.TUnion<[Type.TLiteral<"roundRobin">, Type.TLiteral<"parallel">]>;
+    rounds: Type.TOptional<Type.TInteger>;
+    maxConcurrent: Type.TOptional<Type.TInteger>;
+    timeoutSeconds: Type.TOptional<Type.TInteger>;
+    action: Type.TLiteral<"run">;
+    teamId: Type.TString;
+}>, Type.TObject<{
+    afterSeq: Type.TOptional<Type.TInteger>;
+    seq: Type.TOptional<Type.TInteger>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    action: Type.TLiteral<"read">;
+    teamId: Type.TString;
+}>]>;
+export declare const teamMessageParametersSchema: Type.TObject<{
+    afterSeq: Type.TOptional<Type.TInteger>;
+    seq: Type.TOptional<Type.TInteger>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    action: Type.TUnion<[Type.TLiteral<"read">, Type.TLiteral<"post">]>;
+    teamId: Type.TString;
+    text: Type.TOptional<Type.TString>;
+    replyTo: Type.TOptional<Type.TInteger>;
+}>;
+export declare const teamMessageActionSchema: Type.TUnion<[Type.TObject<{
+    afterSeq: Type.TOptional<Type.TInteger>;
+    seq: Type.TOptional<Type.TInteger>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    action: Type.TLiteral<"read">;
+    teamId: Type.TString;
+}>, Type.TObject<{
+    action: Type.TLiteral<"post">;
+    teamId: Type.TString;
+    text: Type.TString;
+    replyTo: Type.TOptional<Type.TInteger>;
+}>]>;
+export declare const teamPageSchema: Type.TObject<{
+    teamId: Type.TString;
+    messages: Type.TArray<Type.TObject<{
+        seq: Type.TInteger;
+        operationId: Type.TString;
+        author: Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"user">, Type.TLiteral<"coordinator">, Type.TLiteral<"member">]>;
+            agentId: Type.TOptional<Type.TString>;
+            name: Type.TString;
+        }>;
+        text: Type.TString;
+        replyTo: Type.TOptional<Type.TInteger>;
+        runId: Type.TOptional<Type.TString>;
+        source: Type.TOptional<Type.TObject<{
+            requestId: Type.TString;
+            cycleId: Type.TString;
+        }>>;
+        offset: Type.TInteger;
+        totalLength: Type.TInteger;
+        nextOffset: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    }>>;
+    lastSeq: Type.TInteger;
+    nextAfterSeq: Type.TUnion<[Type.TInteger, Type.TNull]>;
+}>;
+export declare const teamResultSchema: Type.TUnion<[Type.TUnion<[Type.TObject<{
+    teamId: Type.TString;
+    name: Type.TString;
+    brief: Type.TString;
+    closed: Type.TBoolean;
+    owned: Type.TLiteral<true>;
+    members: Type.TArray<Type.TObject<{
+        agentId: Type.TString;
+        role: Type.TString;
+        name: Type.TString;
+        state: Type.TString;
+    }>>;
+    lastSeq: Type.TInteger;
+    activeCount: Type.TInteger;
+    unresolved: Type.TArray<Type.TObject<{
+        requestId: Type.TString;
+        agentId: Type.TString;
+        runId: Type.TString;
+        round: Type.TInteger;
+        active: Type.TBoolean;
+        state: Type.TString;
+        cycleId: Type.TOptional<Type.TString>;
+    }>>;
+    run: Type.TOptional<Type.TObject<{
+        runId: Type.TString;
+        instruction: Type.TString;
+        mode: Type.TUnion<[Type.TLiteral<"roundRobin">, Type.TLiteral<"parallel">]>;
+        state: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"paused">, Type.TLiteral<"finished">]>;
+        rounds: Type.TInteger;
+        maxConcurrent: Type.TInteger;
+        deadlineAt: Type.TNumber;
+        scheduled: Type.TInteger;
+        published: Type.TInteger;
+        reason: Type.TOptional<Type.TString>;
+    }>>;
+}>, Type.TObject<{
+    teamId: Type.TString;
+    name: Type.TString;
+    closed: Type.TBoolean;
+    owned: Type.TLiteral<false>;
+}>]>, Type.TObject<{
+    teams: Type.TArray<Type.TUnion<[Type.TObject<{
+        teamId: Type.TString;
+        name: Type.TString;
+        brief: Type.TString;
+        closed: Type.TBoolean;
+        owned: Type.TLiteral<true>;
+        members: Type.TArray<Type.TObject<{
+            agentId: Type.TString;
+            role: Type.TString;
+            name: Type.TString;
+            state: Type.TString;
+        }>>;
+        lastSeq: Type.TInteger;
+        activeCount: Type.TInteger;
+        unresolved: Type.TArray<Type.TObject<{
+            requestId: Type.TString;
+            agentId: Type.TString;
+            runId: Type.TString;
+            round: Type.TInteger;
+            active: Type.TBoolean;
+            state: Type.TString;
+            cycleId: Type.TOptional<Type.TString>;
+        }>>;
+        run: Type.TOptional<Type.TObject<{
+            runId: Type.TString;
+            instruction: Type.TString;
+            mode: Type.TUnion<[Type.TLiteral<"roundRobin">, Type.TLiteral<"parallel">]>;
+            state: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"paused">, Type.TLiteral<"finished">]>;
+            rounds: Type.TInteger;
+            maxConcurrent: Type.TInteger;
+            deadlineAt: Type.TNumber;
+            scheduled: Type.TInteger;
+            published: Type.TInteger;
+            reason: Type.TOptional<Type.TString>;
+        }>>;
+    }>, Type.TObject<{
+        teamId: Type.TString;
+        name: Type.TString;
+        closed: Type.TBoolean;
+        owned: Type.TLiteral<false>;
+    }>]>>;
+}>, Type.TObject<{
+    teamId: Type.TString;
+    messages: Type.TArray<Type.TObject<{
+        seq: Type.TInteger;
+        operationId: Type.TString;
+        author: Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"user">, Type.TLiteral<"coordinator">, Type.TLiteral<"member">]>;
+            agentId: Type.TOptional<Type.TString>;
+            name: Type.TString;
+        }>;
+        text: Type.TString;
+        replyTo: Type.TOptional<Type.TInteger>;
+        runId: Type.TOptional<Type.TString>;
+        source: Type.TOptional<Type.TObject<{
+            requestId: Type.TString;
+            cycleId: Type.TString;
+        }>>;
+        offset: Type.TInteger;
+        totalLength: Type.TInteger;
+        nextOffset: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    }>>;
+    lastSeq: Type.TInteger;
+    nextAfterSeq: Type.TUnion<[Type.TInteger, Type.TNull]>;
+}>]>;
+export declare const teamMessageResultSchema: Type.TUnion<[Type.TObject<{
+    teamId: Type.TString;
+    messages: Type.TArray<Type.TObject<{
+        seq: Type.TInteger;
+        operationId: Type.TString;
+        author: Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"user">, Type.TLiteral<"coordinator">, Type.TLiteral<"member">]>;
+            agentId: Type.TOptional<Type.TString>;
+            name: Type.TString;
+        }>;
+        text: Type.TString;
+        replyTo: Type.TOptional<Type.TInteger>;
+        runId: Type.TOptional<Type.TString>;
+        source: Type.TOptional<Type.TObject<{
+            requestId: Type.TString;
+            cycleId: Type.TString;
+        }>>;
+        offset: Type.TInteger;
+        totalLength: Type.TInteger;
+        nextOffset: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    }>>;
+    lastSeq: Type.TInteger;
+    nextAfterSeq: Type.TUnion<[Type.TInteger, Type.TNull]>;
+}>, Type.TObject<{
+    teamId: Type.TString;
+    seq: Type.TInteger;
+    status: Type.TLiteral<"stored">;
+}>]>;

package/lib/tools/teams/contract.js

@@ -0,0 +1,67 @@
+import { Type } from "typebox";
+export const teamDescription = "主会话管理固定成员团队。create 不启动模型；run 开展有限 roundRobin 轮流讨论或 parallel 并行轮次，默认 2 轮、整批 15 分钟，成员直接取得公共原文。团队运行时占用成员；pause 停止新安排和领取，允许在途工作收尾，之后可私人 send；需要中止成员用 pbot_agent stop。到期时子入口尽力中止未被人工接管的团队工作。close 保留成员会话和历史；换成员须关闭旧团队再创建。继续须明确 run 新批次，不重放旧请求。完成仍需业务验收。";
+export const teamMessageDescription = "直接读取/发布团队公共原文。post 不唤醒模型、不增加轮次，所有成员可见，不提供私信或递归委派。成员只能在自己的团队工作中 post。read 用 afterSeq 分页；长消息用 seq/offset/limit 继续，nextOffset 非空表示该条正文不完整。保存成功不是模型已读或业务完成。";
+const id = Type.String({ minLength: 1, maxLength: 128 });
+const text = Type.String({ minLength: 1, maxLength: 24000 });
+const name = Type.String({ minLength: 1, maxLength: 64, pattern: "^[^\\r\\n\\x00-\\x1f]+$" });
+const mode = Type.Union([Type.Literal("roundRobin"), Type.Literal("parallel")], { description: "run 必填：roundRobin 按成员顺序轮流发言；parallel 在并发上限内发言，全员本轮完成后才进入下一轮。" });
+const members = Type.Array(Type.Object({ agentId: id, role: Type.String({ minLength: 1, maxLength: 4000 }) }, { additionalProperties: false }), {
+    minItems: 1, maxItems: 50, description: "仅 create，必填：固定成员及职责。成员须属于当前父会话分支、版本兼容且未加入其他未关闭团队。create 不启动模型，也不等待成员就绪。",
+});
+const run = {
+    instruction: Type.String({ ...text, description: "仅 run，必填：本次新批次的明确任务与交付要求；不恢复或重放旧批次。" }), mode,
+    rounds: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, description: "仅 run：每位成员的轮数，默认 2。" })),
+    maxConcurrent: Type.Optional(Type.Integer({ minimum: 1, maximum: 50, description: "仅 run：roundRobin 默认且只允许 1；parallel 默认 min(2, 成员数)。不得超过成员数；已排队但未完成的请求也占用并发名额。" })),
+    timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1, maximum: 86400, description: "仅 run：整批期限，默认 900 秒，包含所有轮次和等待。到期停止新安排和领取，子入口尽力中止未被人工接管的在途工作；pause 则允许在途工作收尾。" })),
+};
+const page = {
+    afterSeq: Type.Optional(Type.Integer({ minimum: 0, description: "仅 read：读取序号大于此值的消息，默认 0，不得超过 lastSeq。返回 nextAfterSeq 用于继续消息列表；单条续读使用 seq/offset，省略 afterSeq。先补完被截断的正文，再继续列表。" })),
+    seq: Type.Optional(Type.Integer({ minimum: 1, description: "仅 read：指定一条消息，配合该消息的 nextOffset 续读。未指定时从 afterSeq 后顺序读取。" })),
+    offset: Type.Optional(Type.Integer({ minimum: 0, description: "仅 read：指定 seq 的正文 UTF-16 字符偏移，默认 0；非零时必须同时提供 seq。" })),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 16000, description: "仅 read：本页所有消息正文合计的 UTF-16 字符上限，默认 16000，不是消息条数或 token 数；不含元数据和 Markdown 格式开销。" })),
+};
+const object = (fields) => Type.Object(fields, { additionalProperties: false });
+export const teamParametersSchema = object({
+    action: Type.Union(["create", "list", "status", "read", "run", "pause", "close"].map(v => Type.Literal(v)), {
+        description: "create 只接受并必填 name/brief/members；list 只接受 action；status/pause/close 只接受并必填 teamId；read 必填 teamId，可选 afterSeq/seq/offset/limit；run 必填 teamId/instruction/mode，可选 rounds/maxConcurrent/timeoutSeconds。禁止携带其他 action 的字段。run 要求所有成员存活、idle、当前代次团队接入就绪、无待处理私人输入，且团队未关闭、无运行批次或在途工作。pause 仅停止新安排和未领取请求；close 要求先暂停并等待在途工作结束，不停止成员会话。",
+    }),
+    teamId: Type.Optional(id), name: Type.Optional(name), brief: Type.Optional(text), members: Type.Optional(members),
+    instruction: Type.Optional(run.instruction), mode: Type.Optional(mode), rounds: run.rounds, maxConcurrent: run.maxConcurrent, timeoutSeconds: run.timeoutSeconds, ...page,
+});
+export const teamActionSchema = Type.Union([
+    object({ action: Type.Literal("create"), name, brief: text, members }),
+    object({ action: Type.Literal("list") }),
+    ...["status", "pause", "close"].map(v => object({ action: Type.Literal(v), teamId: id })),
+    object({ action: Type.Literal("run"), teamId: id, ...run }),
+    object({ action: Type.Literal("read"), teamId: id, ...page }),
+]);
+export const teamMessageParametersSchema = object({
+    action: Type.Union([Type.Literal("read"), Type.Literal("post")], {
+        description: "read 必填 teamId，只可选 afterSeq/seq/offset/limit，禁止 text/replyTo；post 必填 teamId/text，只可选 replyTo，禁止所有分页字段。",
+    }), teamId: id, text: Type.Optional(Type.String({ ...text, description: "仅 post，必填：向全体成员公开的原文，不扩大任务授权。" })),
+    replyTo: Type.Optional(Type.Integer({ minimum: 1, description: "仅 post：回复已有消息的 seq。" })), ...page,
+});
+export const teamMessageActionSchema = Type.Union([
+    object({ action: Type.Literal("read"), teamId: id, ...page }),
+    object({ action: Type.Literal("post"), teamId: id, text, replyTo: Type.Optional(Type.Integer({ minimum: 1 })) }),
+]);
+const message = object({ seq: Type.Integer(), operationId: Type.String(),
+    author: object({ kind: Type.Union([Type.Literal("user"), Type.Literal("coordinator"), Type.Literal("member")]), agentId: Type.Optional(id), name: Type.String() }),
+    text: Type.String(), replyTo: Type.Optional(Type.Integer()), runId: Type.Optional(id),
+    source: Type.Optional(object({ requestId: id, cycleId: id })),
+    offset: Type.Integer(), totalLength: Type.Integer({ description: "完整正文的 UTF-16 字符数。" }),
+    nextOffset: Type.Union([Type.Integer(), Type.Null()], { description: "非 null 表示本条正文尚未读完；使用相同 teamId、seq 和此 offset 续读。" }) });
+export const teamPageSchema = object({ teamId: id, messages: Type.Array(message), lastSeq: Type.Integer(),
+    nextAfterSeq: Type.Union([Type.Integer(), Type.Null()], { description: "后续消息列表的 afterSeq；null 只表示列表已到末尾，仍须检查每条消息的 nextOffset。指定 seq 时始终为 null。" }) });
+const ownedView = object({ teamId: id, name: Type.String(), brief: Type.String(), closed: Type.Boolean(), owned: Type.Literal(true),
+    members: Type.Array(object({ agentId: id, role: Type.String(), name: Type.String(), state: Type.String() })),
+    lastSeq: Type.Integer(), activeCount: Type.Integer({ description: "所有批次中已领取、执行实例仍存活且尚无完成记录的请求数；paused 仍可能大于 0。" }),
+    unresolved: Type.Array(object({ requestId: id, agentId: id, runId: id, round: Type.Integer(), active: Type.Boolean(),
+        state: Type.String({ description: "queued=运行批次中尚未领取；accepted=已领取且仍在途；uncertain=已领取但执行实例/代次不再匹配、无完成记录；cancelled=批次已停止且未领取，或周期取消；unpublished=已完成但尚未公开有效原文；mixed/interactive=含人工或私人工作，不自动公开；failed/interrupted=失败或中断。不能将 unresolved 当作成功或自动重试许可。" }), cycleId: Type.Optional(id) }), {
+        description: "所有批次中尚未确认完成且公开的请求，包含排队、在途、失败、结果不明和不宜公开的工作；不是仅列出运行中的请求。先核对原请求和业务结果，避免重复执行。",
+    }),
+    run: Type.Optional(object({ runId: id, instruction: Type.String(), mode, state: Type.Union([Type.Literal("running"), Type.Literal("paused"), Type.Literal("finished")]),
+        rounds: Type.Integer(), maxConcurrent: Type.Integer(), deadlineAt: Type.Number(), scheduled: Type.Integer(), published: Type.Integer(), reason: Type.Optional(Type.String()) })) });
+const view = Type.Union([ownedView, object({ teamId: id, name: Type.String(), closed: Type.Boolean(), owned: Type.Literal(false) })]);
+export const teamResultSchema = Type.Union([view, object({ teams: Type.Array(view) }), teamPageSchema]);
+export const teamMessageResultSchema = Type.Union([teamPageSchema, object({ teamId: id, seq: Type.Integer(), status: Type.Literal("stored") })]);

package/lib/tools/teams/dsh-tool.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { TeamService } from "../../services/agents/team-service.js";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { AgentOwner } from "../../model/agent.js";
+import type { TeamActor } from "../../model/team.js";
+export declare function registerDshTeamTool(ctx: Context, agent: Agent, service: TeamService, agents: AgentService, owner: AgentOwner, check: () => void): void;
+export declare function registerDshTeamMessageTool(ctx: Context, agent: Agent, service: TeamService, actor: () => TeamActor, check: () => void): void;

package/lib/tools/teams/dsh-tool.js

@@ -0,0 +1,49 @@
+import { dshParameters, dshOutputSchema } from "../../integrations/dsh/schema.js";
+import { object } from "../../common/json.js";
+import { requireThat, schema } from "../../common/validation.js";
+import { markdownFields } from "../../common/markdown.js";
+import { teamMessagesMarkdown } from "../../integrations/team-context.js";
+import { executeTeam, executeTeamMessage } from "./actions.js";
+import { teamDescription, teamMessageDescription, teamParametersSchema, teamActionSchema, teamResultSchema, teamMessageParametersSchema, teamMessageActionSchema, teamMessageResultSchema } from "./contract.js";
+export function registerDshTeamTool(ctx, agent, service, agents, owner, check) {
+    const validators = new Map(teamActionSchema.anyOf.map(row => [row.properties.action.const, schema(row)]));
+    const validOutput = schema(teamResultSchema);
+    ctx.tools.register({ name: "pbot_team", description: teamDescription, parameters: dshParameters(teamParametersSchema),
+        output: {
+            schema: dshOutputSchema(teamResultSchema),
+            render: (args, value) => [{ type: "text", text: object(args) && args.action === "read"
+                        ? teamMessagesMarkdown(value) : "# 团队\n\n" + markdownFields(value) }],
+        },
+        async execute(args, exec) {
+            check();
+            exec.signal.throwIfAborted();
+            requireThat(exec.agent === agent && object(args) && typeof args.action === "string", "团队工具会话或参数无效。");
+            const valid = validators.get(args.action);
+            requireThat(valid && valid(args), "团队参数无效。");
+            const value = executeTeam(service, agents, args, owner).structuredContent;
+            requireThat(validOutput(value), "团队输出不符合契约。");
+            return value;
+        },
+    });
+}
+export function registerDshTeamMessageTool(ctx, agent, service, actor, check) {
+    const validators = new Map(teamMessageActionSchema.anyOf.map(row => [row.properties.action.const, schema(row)]));
+    const validOutput = schema(teamMessageResultSchema);
+    ctx.tools.register({ name: "pbot_team_message", description: teamMessageDescription, parameters: dshParameters(teamMessageParametersSchema),
+        output: {
+            schema: dshOutputSchema(teamMessageResultSchema),
+            render: (args, value) => [{ type: "text", text: object(args) && args.action === "read"
+                        ? teamMessagesMarkdown(value) : "# 团队消息\n\n" + markdownFields(value) }],
+        },
+        async execute(args, exec) {
+            check();
+            exec.signal.throwIfAborted();
+            requireThat(exec.agent === agent && object(args) && typeof args.action === "string", "团队消息会话或参数无效。");
+            const valid = validators.get(args.action);
+            requireThat(valid && valid(args), "团队消息参数无效。");
+            const value = executeTeamMessage(service, args, actor(), exec.callId).structuredContent;
+            requireThat(validOutput(value), "团队消息输出不符合契约。");
+            return value;
+        },
+    });
+}

package/lib/ui/dsh/attachments.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandSubmitAttachment } from "@deepseek-ai/dsh-commands/types";
+import type { SessionId } from "@deepseek-ai/dsh-session/types";
+/** Native commands admit encoded images and resolve session-owned file receipts. */
+export declare function commandAttachments(ctx: Context, sessionId: SessionId, files: readonly File[], signal: AbortSignal, progress: (message: string) => void): Promise<CommandSubmitAttachment[]>;

package/lib/ui/dsh/attachments.js

@@ -0,0 +1,39 @@
+const images = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+function encodedImage(file, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader(), abort = () => reader.abort();
+        signal.addEventListener("abort", abort, { once: true });
+        reader.onloadend = () => signal.removeEventListener("abort", abort);
+        reader.onerror = () => reject(reader.error ?? new Error("图片读取失败。"));
+        reader.onabort = () => reject(signal.reason ?? new DOMException("图片读取已取消。", "AbortError"));
+        reader.onload = () => {
+            if (typeof reader.result !== "string")
+                reject(new Error("图片读取失败。"));
+            else
+                resolve(reader.result.slice(reader.result.indexOf(",") + 1));
+        };
+        reader.readAsDataURL(file);
+    });
+}
+/** Native commands admit encoded images and resolve session-owned file receipts. */
+export async function commandAttachments(ctx, sessionId, files, signal, progress) {
+    if (files.length > 32)
+        throw new Error("一次最多附加 32 个文件。");
+    const attachments = [];
+    for (const file of files) {
+        signal.throwIfAborted();
+        progress("正在准备附件：" + file.name);
+        if (images.has(file.type)) {
+            attachments.push({ type: "image", mediaType: file.type, name: file.name, data: await encodedImage(file, signal) });
+        }
+        else {
+            const result = await ctx.fileUpload.upload(sessionId, file, file.name, signal, value => progress(`正在上传 ${file.name}：${value.loaded} / ${value.total ?? file.size} 字节`));
+            if (!result.ok)
+                throw new Error(result.error.message);
+            attachments.push({ type: "file", receiptId: result.value.receiptId });
+        }
+    }
+    signal.throwIfAborted();
+    return attachments;
+}

package/lib/ui/dsh/elements.d.ts

@@ -0,0 +1,17 @@
+export declare const record: (value: unknown) => Record<string, unknown>;
+export declare const rows: (value: unknown) => Record<string, unknown>[];
+export declare const text: (value: unknown) => string;
+export declare const objectInput: (value: string) => Record<string, unknown>;
+export declare const lines: (value: string) => string[];
+export declare function element<K extends keyof HTMLElementTagNameMap>(tag: K, content?: string, className?: string): HTMLElementTagNameMap[K];
+export declare function block(value: unknown): HTMLPreElement;
+export declare function note(value: string): HTMLParagraphElement;
+export declare function group(parent: HTMLElement, className?: string): HTMLDivElement;
+export declare function details(parent: HTMLElement, title: string): HTMLDetailsElement;
+export declare function field(parent: HTMLElement, label: string, multiline?: boolean, value?: string): HTMLInputElement | HTMLTextAreaElement;
+export declare function select(parent: HTMLElement, label: string, values: [string, string][]): HTMLSelectElement;
+export declare function badge(state: unknown): HTMLSpanElement;
+export declare function facts(values: [string, unknown][]): HTMLDListElement;
+export declare function empty(title: string, description: string): HTMLDivElement;
+export declare function pageTitle(parent: HTMLElement, title: string, description: string): HTMLElement;
+export declare function time(value: unknown): string;

package/lib/ui/dsh/elements.js

@@ -0,0 +1,79 @@
+import { object } from "../../common/json.js";
+import { stateLabel } from "../presentation.js";
+export const record = (value) => { if (!object(value))
+    throw new Error("管理数据无效。"); return value; };
+export const rows = (value) => Array.isArray(value) ? value.map(record) : [];
+export const text = (value) => value === null || value === undefined ? "" : String(value);
+export const objectInput = (value) => record(JSON.parse(value || "{}"));
+export const lines = (value) => value.split(/\r?\n/).map(item => item.trim()).filter(Boolean);
+export function element(tag, content = "", className = "") {
+    const node = document.createElement(tag);
+    node.textContent = content;
+    node.className = className;
+    return node;
+}
+export function block(value) { return element("pre", typeof value === "string" ? value : JSON.stringify(value, null, 2), "pbot-prose"); }
+export function note(value) { return element("p", value, "pbot-muted"); }
+export function group(parent, className = "pbot-stack") {
+    const node = element("div", "", className);
+    parent.append(node);
+    return node;
+}
+export function details(parent, title) {
+    const node = element("details", "", "pbot-disclosure");
+    node.append(element("summary", title));
+    parent.append(node);
+    return node;
+}
+export function field(parent, label, multiline = false, value = "") {
+    const wrapper = element("label", "", "pbot-field"), input = multiline ? element("textarea") : element("input");
+    wrapper.append(element("span", label));
+    input.value = value;
+    input.setAttribute("aria-label", label);
+    if (input instanceof HTMLTextAreaElement)
+        input.rows = 3;
+    wrapper.append(input);
+    parent.append(wrapper);
+    return input;
+}
+export function select(parent, label, values) {
+    const wrapper = element("label", "", "pbot-field"), input = element("select");
+    wrapper.append(element("span", label));
+    input.setAttribute("aria-label", label);
+    for (const [value, title] of values) {
+        const option = element("option", title);
+        option.value = value;
+        input.append(option);
+    }
+    wrapper.append(input);
+    parent.append(wrapper);
+    return input;
+}
+export function badge(state) {
+    const node = element("span", stateLabel(state), "pbot-badge");
+    node.dataset.state = text(state);
+    return node;
+}
+export function facts(values) {
+    const node = element("dl", "", "pbot-facts");
+    for (const [label, value] of values)
+        node.append(element("dt", label), element("dd", text(value) || "—"));
+    return node;
+}
+export function empty(title, description) {
+    const node = element("div", "", "pbot-empty");
+    node.append(element("h3", title), note(description));
+    return node;
+}
+export function pageTitle(parent, title, description) {
+    const node = element("header", "", "pbot-page-title");
+    node.append(element("h2", title));
+    if (description)
+        node.append(note(description));
+    parent.append(node);
+    return node;
+}
+export function time(value) {
+    const date = new Date(typeof value === "number" ? value : text(value));
+    return Number.isNaN(date.getTime()) ? "" : date.toLocaleString(undefined, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+}

package/lib/ui/dsh/index.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "@deepseek-ai/cordis";
+export declare const name = "personal-bot";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/lib/ui/dsh/index.js

@@ -0,0 +1,13 @@
+import { pbotReadRemote } from "./remote.js";
+import { showManagement } from "./management.js";
+export const name = "personal-bot";
+export const inject = ["remote"];
+export async function apply(ctx) {
+    ctx.remote.$mount(pbotReadRemote);
+    await ctx.plugin({ name: "pbot-management-view", inject: ["commandUi", "remote", "remote.commands", "remote.pbot", "fileUpload"],
+        apply(view) {
+            view.commandUi.decorate({ name: "pbot", available: () => true,
+                ui: { kind: "action", run: session => { showManagement(view, session.sessionId); } } });
+        },
+    });
+}

package/lib/ui/dsh/management.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { SessionId } from "@deepseek-ai/dsh-session/types";
+/** The view owns drafts, uploads and queries. Accepted commands belong to the server workspace. */
+export declare function showManagement(ctx: Context, parentSessionId: SessionId): void;