personal-bot 0.2.3 → 0.2.5

package/src/tools/agents/dsh-tool.ts

@@ -0,0 +1,41 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { dshParameters, dshOutputSchema } from "../../integrations/dsh/schema.js";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { AgentOwner } from "../../model/agent.js";
+import { object, json } from "../../common/json.js";
+import { requireThat, schema } from "../../common/validation.js";
+import { markdownFields } from "../../common/markdown.js";
+import { executeAgent, type AgentInput } from "./actions.js";
+import { agentDescription, agentResultSchema } from "./contract.js";
+import { dshAgentActionSchema, dshAgentParametersSchema } from "./dsh-contract.js";
+
+export function registerDshAgentTool(ctx: Context, agent: Agent, service: AgentService, owner: AgentOwner, check: () => void) {
+  const validators = new Map(dshAgentActionSchema.anyOf.map(row => [row.properties.action.const, schema(row)]));
+  const validOutput = schema(agentResultSchema);
+  ctx.tools.register({ name: "pbot_agent", description: agentDescription,
+    parameters: dshParameters(dshAgentParametersSchema),
+    output: {
+      schema: dshOutputSchema(agentResultSchema),
+      render: (_args, value) => [{ type: "text", text: "# 专家\n\n" + markdownFields(value) }],
+      presentationMeta: (args, value) => {
+        if (!object(args) || args.action !== "read" || !object(value) || !object(value.cycle) || value.cycle.state === "running") return {};
+        return json({ pbotAgentReadKeys: [String(value.agentId) + ":" + String(value.cycle.cycleId)] });
+      },
+    },
+    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), "dsh 专家参数无效或包含不支持的宿主选项。");
+      const selection = agent.model.current();
+      const output = await executeAgent(service, args as AgentInput, owner, selection ? {
+        provider: selection.provider, model: selection.model,
+        ...(selection.reasoningEffort && (!args.provider || args.provider === selection.provider) && (!args.model || args.model === selection.model)
+          ? { thinking: selection.reasoningEffort } : {}),
+      } : {});
+      requireThat(validOutput(output.structuredContent), "专家输出不符合契约。");
+      return output.structuredContent;
+    },
+  });
+}

package/src/tools/agents/tool.ts

@@ -1,61 +1,25 @@
-import type { Static } from "typebox";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import type { AgentService } from "../../services/agents/agent-service.js";
 import { agentOwner } from "../../integrations/pi/agent-context.js";
-import type { AgentOptions, AgentView } from "../../model/agent.js";
 import type { CallAccess } from "../access.js";
 import { requireThat, schema } from "../../common/validation.js";
-import { markdownResult } from "../result.js";
-import { agentActionSchema, agentParametersSchema, agentResultSchema, agentViewSchema } from "./contract.js";
-
-type AgentOutput = Static<typeof agentViewSchema>;
-function agentOutput(view: AgentView & Partial<AgentOutput>): AgentOutput {
-  const c = view.cycle;
-  return {
-    agentId: view.agentId, name: view.name, cwd: view.cwd, createdAt: view.createdAt,
-    owned: view.owned, state: view.state, activity: view.activity,
-    ...(c ? { cycle: { cycleId: c.cycleId, startedAt: c.startedAt, state: c.state, requestIds: c.requestIds, source: c.source,
-      ...(c.finishedAt === undefined ? {} : { finishedAt: c.finishedAt }), ...(c.error === undefined ? {} : { error: c.error }) } } : {}),
-    ...(view.error === undefined ? {} : { error: view.error }),
-    ...(view.requestId === undefined ? {} : { requestId: view.requestId }),
-    ...(view.messageStatus === undefined ? {} : { messageStatus: view.messageStatus }),
-    ...(view.cycles === undefined ? {} : { cycles: view.cycles }),
-    ...(view.report === undefined ? {} : { report: view.report }),
-    ...(view.totalLength === undefined ? {} : { totalLength: view.totalLength }),
-    ...(view.nextOffset === undefined ? {} : { nextOffset: view.nextOffset }),
-  };
-}
+import { executeAgent } from "./actions.js";
+import { agentDescription, agentActionSchema, agentParametersSchema, agentResultSchema } from "./contract.js";
 
 export function agentTool(service: AgentService, access: CallAccess) {
   const validators = new Map(agentActionSchema.anyOf.map(action => [action.properties.action.const, schema(action)]));
   return defineTool({ name: "pbot_agent", label: "子会话",
-    description: "独立 Pi 子会话，不继承父聊天历史。start 立即返回；未提供 message/prompts/files 时只启动待命进程，不调用模型。完成自动通知，无需轮询。团队占用期间不能私人 send。send 继续对话，rename 改名，status/list 查看状态，status 返回最近周期且不读取报告正文。read 非阻塞读取报告；读取已结束周期会领取该周期的完成通知（包括部分读取），后续不再重复通知。nextOffset 非空时以返回的 cycle.cycleId 固定周期续读。state 是进程状态，cycle.state 是工作结果，queued 仅表示入队。stop 停止并保留历史，resume 携新 message 恢复，不重放旧工作。独立复核须 start 新上下文。子会话使用原生 CLI/MCP，按委派范围工作，不递归委派。每个父会话最多 50 个存活子会话，空闲也计入。",
+    description: agentDescription,
     parameters: agentParametersSchema, outputSchema: agentResultSchema,
     async execute(_id, args, signal, _update, ctx) {
       access.check(); signal?.throwIfAborted();
       const valid = validators.get(args.action);
       requireThat(valid, "未知的子会话 action：" + args.action);
       requireThat(valid(args), "子会话 " + args.action + " 参数无效：" + JSON.stringify(valid.errors));
-      const input = args as Static<typeof agentParametersSchema>, owner = agentOwner(ctx);
-      let value: AgentView & Partial<AgentOutput>;
-      switch (input.action) {
-        case "start": {
-          const { action: _action, ...supplied } = input;
-          value = service.start({ provider: ctx.model?.provider, model: ctx.model?.id, thinking: ctx.thinkingLevel, ...supplied } as AgentOptions, owner); break;
-        }
-        case "list": return markdownResult({ agents: service.list(owner).map(agentOutput) }, "子会话列表");
-        case "send": value = service.send(input.agentId!, input.message!, input.delivery ?? "steer", owner); break;
-        case "rename": value = service.rename(input.agentId!, input.name!, owner); break;
-        case "resume": value = service.resume(input.agentId!, input.message!, owner); break;
-        case "stop": value = service.stop(input.agentId!, owner); break;
-        case "status": value = service.status(input.agentId!, owner); break;
-        case "read": {
-          const page = service.read(input.agentId!, owner, input.cycleId, input.offset, input.limit);
-          const data = agentOutput(page), output = markdownResult(data, "子会话报告");
-          return { ...output, details: { ...data, ...(page.cycle && page.cycle.state !== "running" ? { agentReadKeys: [page.agentId + ":" + page.cycle.cycleId] } : {}) } };
-        }
-      }
-      return markdownResult(agentOutput(value), "子会话状态");
+      return executeAgent(service, args, agentOwner(ctx), {
+        ...(ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : {}),
+        ...(ctx.thinkingLevel ? { thinking: ctx.thinkingLevel } : {}),
+      });
     },
   });
 }

package/src/tools/history/actions.ts

@@ -0,0 +1,9 @@
+import type { HistoryLocation } from "../../model/history.js";
+import type { HistoryService } from "../../services/history/history-service.js";
+import type { HistoryInput } from "./contract.js";
+
+export async function executeHistory(service: HistoryService, args: HistoryInput, location: HistoryLocation, signal?: AbortSignal) {
+  signal?.throwIfAborted(); await service.refresh(location, signal); signal?.throwIfAborted();
+  return args.action === "search" ? service.search(args) :
+    { node: service.read(args.id!, args.offset, args.limit, args.childrenOffset, args.host), warnings: service.warnings };
+}

package/src/tools/history/contract.ts

@@ -0,0 +1,34 @@
+import { Type, type Static } from "typebox";
+import { requireThat, schema } from "../../common/validation.js";
+
+const host = Type.Union([Type.Literal("pi"), Type.Literal("dsh")]);
+const nullableOffset = Type.Union([Type.Integer(), Type.Null()]);
+const node = Type.Object({ host, id: Type.String(), kind: Type.Union([Type.Literal("session"), Type.Literal("exchange"), Type.Literal("summary")]),
+  sessionId: Type.String(), name: Type.String(), preview: Type.String(), from: Type.String(), to: Type.String(), ready: Type.Boolean(), completed: Type.Boolean() });
+export const historyResultSchema = Type.Object({
+  matches: Type.Optional(Type.Array(Type.Object({ ...node.properties, snippet: Type.String(), parents: Type.Array(Type.String()) }))),
+  total: Type.Optional(Type.Integer()), nextOffset: Type.Optional(nullableOffset),
+  node: Type.Optional(Type.Object({ ...node.properties, text: Type.String(), totalLength: Type.Integer(), nextOffset: nullableOffset,
+    parents: Type.Array(node), children: Type.Array(node), nextChildrenOffset: nullableOffset,
+    source: Type.Object({ host, sessionId: Type.String({ description: "原始宿主会话 ID；来源不保存文件路径。" }), entryIds: Type.Array(Type.String()) }), warnings: Type.Array(Type.String()) })),
+  warnings: Type.Array(Type.String()),
+});
+export const historyDescription = "查询当前工作区的 Pi 与 dsh 历史归档，可用 host 筛选来源。search 对问答原文和各层摘要做不区分大小写的连续文本匹配；省略 query 列出会话。忘记原词时换几组词查询。read 读取命中节点并返回父子节点；沿 parents/children 的 id 展开，nextOffset 续读正文，nextChildrenOffset 续读子节点。摘要是检索线索，重要结论回到 exchange 原文核对。共享前缀可能有多个父节点。查询不调用模型，不恢复或重放旧任务；只更新当前宿主的原生历史索引。问答归档不代替专家的完整工具日志。";
+export const historyParameters = Type.Object({ action: Type.Union([Type.Literal("search"), Type.Literal("read")]),
+  host: Type.Optional(host), query: Type.Optional(Type.String()), sessionId: Type.Optional(Type.String()),
+  from: Type.Optional(Type.String({ description: "search：ISO 日期或时间，下界。" })),
+  to: Type.Optional(Type.String({ description: "search：ISO 日期或时间，上界。" })),
+  id: Type.Optional(Type.String({ description: "read 必填：返回的节点 id。" })),
+  offset: Type.Optional(Type.Integer({ minimum: 0 })),
+  limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 24000, description: "search：最多 50 条，默认 20；read：字符数，默认 12000。" })),
+  childrenOffset: Type.Optional(Type.Integer({ minimum: 0 })),
+}, { additionalProperties: false });
+export type HistoryInput = Static<typeof historyParameters>;
+const valid = schema(historyParameters);
+export function historyInput(value: unknown): HistoryInput {
+  requireThat(valid(value), "历史参数无效。");
+  const args = value as HistoryInput;
+  requireThat(args.action !== "read" || args.id, "read 需要节点 id。");
+  requireThat(args.action !== "search" || (args.limit ?? 20) <= 50, "search limit 最多 50。");
+  return args;
+}

package/src/tools/history/dsh-tool.ts

@@ -0,0 +1,22 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { HistoryService } from "../../services/history/history-service.js";
+import { dshParameters, dshOutputSchema } from "../../integrations/dsh/schema.js";
+import { requireThat, schema } from "../../common/validation.js";
+import { json } from "../../common/json.js";
+import { markdownFields } from "../../common/markdown.js";
+import { historyDescription, historyInput, historyParameters, historyResultSchema } from "./contract.js";
+import { executeHistory } from "./actions.js";
+
+export function registerDshHistoryTool(ctx: Context, agent: Agent, service: HistoryService, lifetime: AbortSignal, check: () => void) {
+  const valid = schema(historyResultSchema);
+  ctx.tools.register({ name: "pbot_history", description: historyDescription, parameters: dshParameters(historyParameters),
+    output: { schema: dshOutputSchema(historyResultSchema), render: (_args, value) => [{ type: "text", text: "# 历史\n\n" + markdownFields(value) }] },
+    async execute(value, exec) {
+      check(); requireThat(exec.agent === agent, "历史工具不属于当前会话。");
+      const signal = AbortSignal.any([exec.signal, lifetime]);
+      const result = await executeHistory(service, historyInput(value), { host: "dsh", sessionId: agent.id }, signal);
+      check(); signal.throwIfAborted(); requireThat(valid(result), "历史输出不符合契约。"); return json(result);
+    },
+  });
+}

package/src/tools/history/tool.ts

@@ -1,42 +1,19 @@
-import { Type } from "typebox";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import type { HistoryService } from "../../services/history/history-service.js";
 import type { CallAccess } from "../access.js";
 import { historyLocation } from "../../integrations/pi/history.js";
-import { requireThat } from "../../common/validation.js";
 import { markdownResult } from "../result.js";
+import { historyDescription, historyInput, historyParameters, historyResultSchema } from "./contract.js";
+import { executeHistory } from "./actions.js";
 
-const nullableOffset = Type.Union([Type.Integer(), Type.Null()]);
-const node = Type.Object({ id: Type.String(), kind: Type.Union([Type.Literal("session"), Type.Literal("exchange"), Type.Literal("summary")]),
-  sessionId: Type.String(), name: Type.String(), preview: Type.String(), from: Type.String(), to: Type.String(), ready: Type.Boolean(), completed: Type.Boolean() });
-const resultSchema = Type.Object({
-  matches: Type.Optional(Type.Array(Type.Object({ ...node.properties, snippet: Type.String(), parents: Type.Array(Type.String()) }))),
-  total: Type.Optional(Type.Integer()), nextOffset: Type.Optional(nullableOffset),
-  node: Type.Optional(Type.Object({ ...node.properties, text: Type.String(), totalLength: Type.Integer(), nextOffset: nullableOffset,
-    parents: Type.Array(node), children: Type.Array(node), nextChildrenOffset: nullableOffset,
-    source: Type.Object({ sessionId: Type.String({ description: "原始 Pi 会话 ID；来源不保存文件路径。" }), entryIds: Type.Array(Type.String()) }), warnings: Type.Array(Type.String()) })),
-  warnings: Type.Array(Type.String()),
-});
 export function historyTool(service: HistoryService, access: CallAccess) {
-  return defineTool({ name: "pbot_history", label: "历史对话",
-    description: "查询当前工作区的 Pi 历史。search 对问答原文和各层摘要做不区分大小写的连续文本匹配；省略 query 列出会话。忘记原词时换几组词查询。read 读取命中节点并返回父子节点；沿 parents/children 的 id 展开，nextOffset 续读正文，nextChildrenOffset 续读子节点。摘要是检索线索，重要结论回到 exchange 原文核对。共享前缀可能有多个父节点。查询不调用模型，不恢复或重放旧任务。",
-    parameters: Type.Object({ action: Type.Union([Type.Literal("search"), Type.Literal("read")]),
-      query: Type.Optional(Type.String()), sessionId: Type.Optional(Type.String()),
-      from: Type.Optional(Type.String({ description: "search：ISO 日期或时间，下界。" })),
-      to: Type.Optional(Type.String({ description: "search：ISO 日期或时间，上界。" })),
-      id: Type.Optional(Type.String({ description: "read 必填：返回的节点 id。" })),
-      offset: Type.Optional(Type.Integer({ minimum: 0 })),
-      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 24000, description: "search：最多 50 条，默认 20；read：字符数，默认 12000。" })),
-      childrenOffset: Type.Optional(Type.Integer({ minimum: 0 })),
-    }, { additionalProperties: false }), outputSchema: resultSchema,
+  return defineTool({ name: "pbot_history", label: "历史对话", description: historyDescription,
+    parameters: historyParameters, outputSchema: historyResultSchema,
     async execute(_id, args, signal, _update, ctx) {
-      access.check(); signal?.throwIfAborted();
-      requireThat(args.action !== "read" || args.id, "read 需要节点 id。");
-      requireThat(args.action !== "search" || (args.limit ?? 20) <= 50, "search limit 最多 50。");
-      await service.refresh(historyLocation(ctx), signal);
       access.check();
-      return args.action === "search" ? markdownResult(service.search(args), "历史搜索")
-        : markdownResult({ node: service.read(args.id!, args.offset, args.limit, args.childrenOffset), warnings: service.warnings }, "历史正文");
+      const result = await executeHistory(service, historyInput(args), historyLocation(ctx), signal);
+      access.check();
+      return markdownResult(result, args.action === "search" ? "历史搜索" : "历史正文");
     },
   });
 }

package/src/tools/teams/actions.ts

@@ -0,0 +1,38 @@
+import type { Static } from "typebox";
+import type { TeamService } from "../../services/agents/team-service.js";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { TeamActor } from "../../model/team.js";
+import type { AgentOwner } from "../../model/agent.js";
+import { teamMessagesMarkdown } from "../../integrations/team-context.js";
+import { markdownResult, result } from "../result.js";
+import type { teamParametersSchema, teamMessageParametersSchema } from "./contract.js";
+
+export function executeTeam(service: TeamService, agents: AgentService, input: Static<typeof teamParametersSchema>, owner: AgentOwner) {
+  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: TeamService, input: Static<typeof teamMessageParametersSchema>, actor: TeamActor, requestId: string) {
+  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/src/tools/teams/contract.ts

@@ -1,4 +1,8 @@
 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 非空表示该条正文不完整。保存成功不是模型已读或业务完成。";
+
 import type { TSchema } from "typebox";
 
 const id = Type.String({ minLength: 1, maxLength: 128 });
@@ -23,7 +27,7 @@ const page = {
 const object = <T extends Record<string, TSchema>>(fields: T) => 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 要求先暂停并等待在途工作结束，不停止成员进程。",
+    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,
@@ -55,9 +59,9 @@ export const teamPageSchema = object({ teamId: id, messages: Type.Array(message)
   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。" }),
+  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) }), {
+    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")]),

package/src/tools/teams/dsh-tool.ts

@@ -0,0 +1,55 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { dshParameters, dshOutputSchema } from "../../integrations/dsh/schema.js";
+import type { Static } from "typebox";
+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";
+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: Context, agent: Agent, service: TeamService, agents: AgentService, owner: AgentOwner, check: () => void) {
+  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 as unknown as ReturnType<TeamService["read"]>) : "# 团队\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 as Static<typeof teamParametersSchema>, owner).structuredContent;
+      requireThat(validOutput(value), "团队输出不符合契约。"); return value;
+    },
+  });
+}
+
+export function registerDshTeamMessageTool(ctx: Context, agent: Agent, service: TeamService, actor: () => TeamActor, check: () => void) {
+  const validators = new Map<string, ReturnType<typeof schema>>(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 as unknown as ReturnType<TeamService["read"]>) : "# 团队消息\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 as Static<typeof teamMessageParametersSchema>, actor(), exec.callId).structuredContent;
+      requireThat(validOutput(value), "团队消息输出不符合契约。"); return value;
+    },
+  });
+}

package/src/tools/teams/tool.ts

@@ -1,63 +1,38 @@
-import type { Static } from "typebox";
 import { defineTool, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TeamService } from "../../services/agents/team-service.js";
 import type { AgentService } from "../../services/agents/agent-service.js";
 import type { TeamActor } from "../../model/team.js";
 import { agentOwner } from "../../integrations/pi/agent-context.js";
-import { teamMessagesMarkdown } from "../../integrations/pi/team-context.js";
 import { requireThat, schema } from "../../common/validation.js";
 import type { CallAccess } from "../access.js";
-import { markdownResult, result } from "../result.js";
-import { teamParametersSchema, teamActionSchema, teamResultSchema, teamMessageParametersSchema, teamMessageActionSchema, teamMessageResultSchema } from "./contract.js";
+import { executeTeam, executeTeamMessage } from "./actions.js";
+import { teamDescription, teamMessageDescription, teamParametersSchema, teamActionSchema, teamResultSchema, teamMessageParametersSchema, teamMessageActionSchema, teamMessageResultSchema } from "./contract.js";
 
 export function teamTool(service: TeamService, agents: AgentService, access: Pick<CallAccess, "check">) {
   const validators = new Map(teamActionSchema.anyOf.map(action => [action.properties.action.const, schema(action)]));
   return defineTool({ name: "pbot_team", label: "团队",
-    description: "主会话管理固定成员团队。create 不启动模型；run 开展有限 roundRobin 轮流讨论或 parallel 并行轮次，默认 2 轮、整批 15 分钟，成员直接取得公共原文。团队运行时占用成员；pause 停止新安排和领取，允许在途工作收尾，之后可私人 send；需要中止成员用 pbot_agent stop。到期时子入口尽力中止未被人工接管的团队工作。close 保留成员进程和历史；换成员须关闭旧团队再创建。继续须明确 run 新批次，不重放旧请求。完成仍需业务验收。",
+    description: teamDescription,
     parameters: teamParametersSchema, outputSchema: teamResultSchema,
     async execute(_id, args, signal, _update, ctx) {
       access.check(); signal?.throwIfAborted();
       const valid = validators.get(args.action);
       requireThat(valid, "未知的团队 action：" + args.action);
       requireThat(valid(args), "团队 " + args.action + " 参数无效：" + JSON.stringify(valid.errors));
-      const input = args as Static<typeof teamParametersSchema>, owner = agentOwner(ctx), 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), "团队状态");
+      return executeTeam(service, agents, args, agentOwner(ctx));
     },
   });
 }
 export function teamMessageTool(service: TeamService, access: Pick<CallAccess, "check">, actor: (ctx: ExtensionContext) => TeamActor) {
   const validators = new Map(teamMessageActionSchema.anyOf.map(action => [action.properties.action.const, schema(action)]));
   return defineTool({ name: "pbot_team_message", label: "团队消息",
-    description: "直接读取/发布团队公共原文。post 不唤醒模型、不增加轮次，所有成员可见，不提供私信或递归委派。成员只能在自己的团队工作中 post。read 用 afterSeq 分页；长消息用 seq/offset/limit 继续，nextOffset 非空表示该条正文不完整。保存成功不是模型已读或业务完成。",
+    description: teamMessageDescription,
     parameters: teamMessageParametersSchema, outputSchema: teamMessageResultSchema,
     async execute(id, args, signal, _update, ctx) {
       access.check(); signal?.throwIfAborted();
       const valid = validators.get(args.action);
       requireThat(valid, "未知的团队消息 action：" + args.action);
       requireThat(valid(args), "团队消息 " + args.action + " 参数无效：" + JSON.stringify(valid.errors));
-      const input = args as Static<typeof teamMessageParametersSchema>, sender = actor(ctx);
-      if (input.action === "read") {
-        const page = service.read(input.teamId, sender, input);
-        return result(page, false, teamMessagesMarkdown(page));
-      }
-      const message = service.post(input.teamId, sender, id, input.text!, input.replyTo);
-      return markdownResult({ teamId: input.teamId, seq: message.seq, status: "stored" }, "团队消息已保存");
+      return executeTeamMessage(service, args, actor(ctx), id);
     },
   });
 }

package/src/ui/agent-display.ts

@@ -1,11 +1,14 @@
 import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { AgentView } from "../model/agent.js";
-export const agentSummary = (v: AgentView) => `${v.name} · ${v.agentId.slice(0, 8)} · ${v.state} · ${v.activity.replace(/\s+/g, " ")}`;
+import { duration, oneLine, stateLabel } from "./presentation.js";
+export const agentSummary = (v: AgentView) => `${v.name} · ${stateLabel(v.state)} · ${v.agentId.slice(0, 8)}`;
 export function agentBoard(values: AgentView[], theme: Theme): Component {
   return { invalidate() {}, render(width) {
-    return values.filter(v => ["starting", "busy", "stopping"].includes(v.state)).map(v => truncateToWidth(
-      theme.fg("accent", "● " + v.name) + theme.fg("dim", ` · ${v.state} · ${Math.max(0, Math.floor((Date.now() - (v.cycle?.startedAt ?? v.createdAt)) / 1000))}s · `) +
-      v.activity.replace(/\s+/g, " "), Math.max(1, width)));
+    const active = values.filter(v => ["starting", "busy", "stopping"].includes(v.state));
+    return [...active.slice(0, 4).map(v => truncateToWidth(
+      theme.fg("accent", v.name) + theme.fg("dim", ` · ${stateLabel(v.state)} · ${duration(Date.now() - (v.cycle?.startedAt ?? v.createdAt))} · `) +
+      oneLine(v.activity), Math.max(1, width))),
+      ...(active.length > 4 ? [truncateToWidth(theme.fg("dim", `另有 ${active.length - 4} 位专家 · /pbot agents`), Math.max(1, width))] : [])];
   } };
 }

package/src/ui/dsh/attachments.ts

@@ -0,0 +1,42 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type {} from "@deepseek-ai/dsh-client-file-upload/client";
+import type { CommandSubmitAttachment } from "@deepseek-ai/dsh-commands/types";
+import type { ImageMediaType } from "@deepseek-ai/dsh-attachment/types";
+import type { SessionId } from "@deepseek-ai/dsh-session/types";
+
+const images = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+
+function encodedImage(file: File, signal: AbortSignal): Promise<string> {
+  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: Context, sessionId: SessionId, files: readonly File[],
+  signal: AbortSignal, progress: (message: string) => void): Promise<CommandSubmitAttachment[]> {
+  if (files.length > 32) throw new Error("一次最多附加 32 个文件。");
+  const attachments: CommandSubmitAttachment[] = [];
+  for (const file of files) {
+    signal.throwIfAborted(); progress("正在准备附件：" + file.name);
+    if (images.has(file.type)) {
+      attachments.push({ type: "image", mediaType: file.type as ImageMediaType, 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/src/ui/dsh/elements.ts

@@ -0,0 +1,50 @@
+import { object } from "../../common/json.js";
+import { stateLabel } from "../presentation.js";
+
+export const record = (value: unknown): Record<string, unknown> => { if (!object(value)) throw new Error("管理数据无效。"); return value; };
+export const rows = (value: unknown) => Array.isArray(value) ? value.map(record) : [];
+export const text = (value: unknown) => value === null || value === undefined ? "" : String(value);
+export const objectInput = (value: string) => record(JSON.parse(value || "{}"));
+export const lines = (value: string) => value.split(/\r?\n/).map(item => item.trim()).filter(Boolean);
+
+export function element<K extends keyof HTMLElementTagNameMap>(tag: K, content = "", className = "") {
+  const node = document.createElement(tag); node.textContent = content; node.className = className; return node;
+}
+export function block(value: unknown) { return element("pre", typeof value === "string" ? value : JSON.stringify(value, null, 2), "pbot-prose"); }
+export function note(value: string) { return element("p", value, "pbot-muted"); }
+export function group(parent: HTMLElement, className = "pbot-stack") {
+  const node = element("div", "", className); parent.append(node); return node;
+}
+export function details(parent: HTMLElement, title: string) {
+  const node = element("details", "", "pbot-disclosure"); node.append(element("summary", title)); parent.append(node); return node;
+}
+export function field(parent: HTMLElement, label: string, 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: HTMLElement, label: string, values: [string, string][]) {
+  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: unknown) {
+  const node = element("span", stateLabel(state), "pbot-badge"); node.dataset.state = text(state); return node;
+}
+export function facts(values: [string, unknown][]) {
+  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: string, description: string) {
+  const node = element("div", "", "pbot-empty"); node.append(element("h3", title), note(description)); return node;
+}
+export function pageTitle(parent: HTMLElement, title: string, description: string) {
+  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: unknown) {
+  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/src/ui/dsh/index.ts

@@ -0,0 +1,18 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type {} from "@deepseek-ai/dsh-api-remotes/client";
+import type {} from "@deepseek-ai/dsh-client-ui-commands/client";
+import { pbotReadRemote } from "./remote.js";
+import { showManagement } from "./management.js";
+
+export const name = "personal-bot";
+export const inject = ["remote"];
+
+export async function apply(ctx: Context) {
+  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); } } });
+    },
+  });
+}