@lemoncat7/dsh-partner 1.4.2 → 1.5.1

package/lib/agent-runtime.js

@@ -2,13 +2,15 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, realpath, stat, writeFile } from 'node:fs/promises';
 import { basename, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { BlockAssembler, createToolResultMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
-import { createScope, scopeOf } from '@deepseek-ai/dsh-scope';
+import { createScope, scopeOf, scopeParentOf } from '@deepseek-ai/dsh-scope';
 import { concernObservationPrompt } from './autonomy.js';
 import { boundedConcernCheckMinutes } from './concern-domain.js';
 import { PARTNER_MEDIA_MAX_BYTES, safeMediaName } from './channel-message.js';
 import { listConcernFileSources } from './concern-sources.js';
 import { CONCERN_CREATED_NOTICE, renderConcernCreatedNotice } from './concern-notification.js';
 import { HEARTBEAT_LOCAL_COMMAND, heartbeatLocalCommandTool } from './heartbeat-command.js';
+import { assistantTextAfter, renderPartnerPersona, renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
+export { renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
 const HEARTBEAT_TIMEOUT_MS = 115_000;
 const HEARTBEAT_DISCOVERY_BUDGET_MS = 72_000;
 const HEARTBEAT_TOOL_TIMEOUT_MS = 18_000;
@@ -19,6 +21,7 @@ const HEARTBEAT_WEB_FETCH_RESULT_LIMIT = 40_000;
 const HEARTBEAT_WEB_SOURCE_RESULT_LIMIT = 125_000;
 const HEARTBEAT_AUDIT_INPUT_LIMIT = 320;
 const HEARTBEAT_AUDIT_OUTPUT_LIMIT = 520;
+const PARTNER_TASK_TIMEOUT_MS = 30 * 60_000;
 const HEARTBEAT_READ_ONLY_TOOLS = new Set([
     'knowledge_base_search',
     'knowledge_search',
@@ -40,19 +43,34 @@ export class PartnerAgentRuntime {
     memory;
     reflection;
     concerns;
+    composer;
     handles = new Map();
     queues = new Map();
     heartbeatQueues = new Map();
+    taskQueues = new Map();
     steeringQueues = new Map();
     workspaces = new Map();
     profileVersions = new Map();
-    constructor(ctx, store, defaultCwd, memory, reflection, concerns) {
+    restoredCompositions = new Map();
+    restoredCompositionJobs = new Map();
+    disposeAgentListener;
+    constructor(ctx, store, defaultCwd, memory, reflection, concerns, composer) {
         this.ctx = ctx;
         this.store = store;
         this.defaultCwd = defaultCwd;
         this.memory = memory;
         this.reflection = reflection;
         this.concerns = concerns;
+        this.composer = composer;
+        this.disposeAgentListener = typeof this.ctx.on === 'function'
+            ? this.ctx.on('agent/disposed', ({ agent }) => {
+                const restored = this.restoredCompositions.get(agent.session.id);
+                if (restored?.agent !== agent)
+                    return;
+                restored.dispose();
+                this.restoredCompositions.delete(agent.session.id);
+            })
+            : () => { };
     }
     async reply(companion, channelId, userId, message) {
         const key = `${channelId}:${userId}`;
@@ -122,6 +140,114 @@ export class PartnerAgentRuntime {
         await this.ensureAgent(companion, route);
         return route;
     }
+    async ensureLocalSessionRecord(companionId) {
+        const companion = this.store.snapshot().companions.find(item => item.id === companionId);
+        if (companion === undefined)
+            throw new Error('伙伴身份不存在');
+        const existing = this.store.snapshot().sessions.find(item => item.companionId === companionId && item.kind === 'local');
+        if (existing !== undefined && canReuseSession(existing, companion.id, this.ctx.workspaceRegistry.archivedSessionIds)) {
+            return existing;
+        }
+        const now = Date.now();
+        const route = {
+            id: `route-${randomUUID()}`,
+            kind: 'local',
+            channelId: '@local',
+            userId: `owner:${companion.id}`,
+            companionId: companion.id,
+            sessionId: `session-${randomUUID()}`,
+            cwd: partnerCwd(this.defaultCwd, companion.id),
+            lastMessageAt: now,
+        };
+        await this.store.update(state => {
+            state.sessions = state.sessions.filter(item => !(item.companionId === companion.id && item.kind === 'local'));
+            state.sessions.push(route);
+        });
+        return route;
+    }
+    async createLocalSession(companionId) {
+        const companion = this.store.snapshot().companions.find(item => item.id === companionId);
+        if (companion === undefined)
+            throw new Error('伙伴身份不存在');
+        const route = await this.ensureLocalSessionRecord(companionId);
+        await this.ensureAgent(companion, route);
+        return route;
+    }
+    async notifyTaskProgress(task, previousStatus) {
+        if (!task.creatorCompanionId || (task.status !== 'review' && task.status !== 'done' && task.status !== 'blocked'))
+            return;
+        const companion = this.store.snapshot().companions.find(item => item.id === task.creatorCompanionId);
+        if (!companion)
+            return;
+        const state = this.store.snapshot();
+        const routes = state.sessions.filter(item => item.companionId === companion.id);
+        const downstream = state.tasks.filter(item => item.dependencyTaskIds.includes(task.id) && item.status !== 'done');
+        const route = selectTaskNotificationRoute(routes, task.creatorSessionId, item => this.isArchived(item))
+            ?? await this.createLocalSession(companion.id);
+        const agent = await this.ensureAgent(companion, route);
+        const isReviewer = task.status === 'review' && task.reviewerCompanionId === companion.id;
+        const instruction = isReviewer
+            ? '这是你创建并分配的看板任务，执行伙伴已提交结果，现在默认由你验收。请根据任务要求真实核验已有产出；通过后必须调用 partner_task_board accept，不通过则调用 reject 并写明原因。不要重新执行该任务。'
+            : task.status === 'review'
+                ? '这是你创建并分配的看板任务进度事件。执行结果已提交并等待指定伙伴验收；不要重新执行，请向用户简要说明当前进度。'
+                : task.status === 'done'
+                    ? '这是你创建并分配的看板任务终态事件。不要重新执行已完成的工作。请检查依赖它的后续任务是否解锁，需要时继续在看板上分配。对用户的终态结果由系统直接投递，不要只改写成“已完成”或进度摘要。'
+                    : '这是你创建并分配的看板任务受阻事件。请保留已有产出、检查是否能调整分工或解锁依赖；需要用户介入时，明确说明阻塞原因与所需动作。';
+        agent.followup(createUserMessage({
+            content: [{ type: 'text', text: [
+                        instruction,
+                        `任务：${task.title}`,
+                        `状态：${previousStatus} → ${task.status}`,
+                        task.resultSummary ? `结果：\n${task.resultSummary.slice(0, 3000)}` : '',
+                        task.status === 'review' && task.reviewHandoff ? `验收交接：\n${task.reviewHandoff.slice(0, 2000)}` : '',
+                        task.reviewSummary ? `验收：\n${task.reviewSummary.slice(0, 2000)}` : '',
+                        downstream.length > 0 ? `后续任务：\n${downstream.map(item => `- ${item.title}（${item.status}）`).join('\n')}` : '没有依赖此任务的后续任务。',
+                    ].filter(Boolean).join('\n\n') }],
+            source: { kind: 'plugin', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: taskProgressNoticeSummary(task.status) },
+        }));
+    }
+    async executeTask(input) {
+        const route = await this.createLocalSession(input.companion.id);
+        const key = route.sessionId;
+        const previous = this.taskQueues.get(key) ?? Promise.resolve();
+        let output = '';
+        const current = previous.catch(() => { }).then(async () => {
+            const agent = await this.ensureAgent(input.companion, route);
+            if (agent.status !== 'idle')
+                await agent.whenIdle();
+            const startSeq = agent.session.seq;
+            agent.followup(createUserMessage({
+                content: [{ type: 'text', text: input.prompt }],
+                source: { kind: 'plugin', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: input.sourceId.startsWith('review:') ? '伙伴核验看板任务' : '伙伴执行看板任务' },
+            }));
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                agent.cancel({ kind: 'hook', reason: 'partner task execution timed out' });
+            }, PARTNER_TASK_TIMEOUT_MS);
+            timer.unref?.();
+            try {
+                await agent.whenIdle();
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (timedOut)
+                throw new Error('伙伴看板任务执行超时');
+            output = assistantTextAfter(agent, startSeq).trim();
+            if (!output)
+                throw new Error('伙伴会话没有产生任务结果');
+        });
+        this.taskQueues.set(key, current);
+        try {
+            await current;
+            return { run: { id: `session-task-${randomUUID()}` }, output };
+        }
+        finally {
+            if (this.taskQueues.get(key) === current)
+                this.taskQueues.delete(key);
+        }
+    }
     isArchived(route) {
         return this.ctx.workspaceRegistry.archivedSessionIds.includes(route.sessionId);
     }
@@ -131,10 +257,14 @@ export class PartnerAgentRuntime {
             throw new Error('伙伴会话不存在');
         if (!this.isArchived(previous))
             return previous;
+        const companion = this.store.snapshot().companions.find(item => item.id === previous.companionId);
+        if (companion === undefined)
+            throw new Error('伙伴身份不存在');
         const next = renewedSession(previous);
         await this.store.update(state => {
             state.sessions = state.sessions.map(item => item.id === routeId ? next : item);
         });
+        await this.ensureAgent(companion, next);
         return next;
     }
     async heartbeat(companion, route, concerns) {
@@ -351,6 +481,7 @@ export class PartnerAgentRuntime {
             const handle = this.handles.get(item.sessionId);
             this.handles.delete(item.sessionId);
             this.profileVersions.delete(item.sessionId);
+            await this.releaseRestoredComposition(item.sessionId);
             await handle?.dispose().catch(() => { });
         }));
     }
@@ -360,17 +491,31 @@ export class PartnerAgentRuntime {
             const handle = this.handles.get(item.sessionId);
             this.handles.delete(item.sessionId);
             this.profileVersions.delete(item.sessionId);
+            await this.releaseRestoredComposition(item.sessionId);
             await handle?.dispose().catch(() => { });
         }));
         await this.store.update(state => { state.sessions = state.sessions.filter(item => item.channelId !== channelId); });
     }
     async close() {
+        this.disposeAgentListener();
+        await Promise.allSettled(this.restoredCompositionJobs.values());
+        for (const restored of this.restoredCompositions.values())
+            restored.dispose();
+        this.restoredCompositions.clear();
+        this.restoredCompositionJobs.clear();
         await Promise.all([...this.handles.values()].map(handle => handle.dispose().catch(() => { })));
         this.handles.clear();
         this.profileVersions.clear();
         this.heartbeatQueues.clear();
+        this.taskQueues.clear();
         this.steeringQueues.clear();
     }
+    async releaseRestoredComposition(sessionId) {
+        await this.restoredCompositionJobs.get(sessionId)?.catch(() => { });
+        const restored = this.restoredCompositions.get(sessionId);
+        restored?.dispose();
+        this.restoredCompositions.delete(sessionId);
+    }
     async drive(companion, channelId, userId, message) {
         const session = await this.ensureSession(companion, channelId, userId);
         const agent = await this.ensureAgent(companion, session);
@@ -398,7 +543,7 @@ export class PartnerAgentRuntime {
             source: { kind: 'user' },
         }));
         await agent.whenIdle();
-        const response = extractAssistantText(agent, startSeq);
+        const response = assistantTextAfter(agent, startSeq);
         await this.store.update(state => {
             const target = state.sessions.find(item => item.id === session.id);
             if (target)
@@ -443,6 +588,7 @@ export class PartnerAgentRuntime {
         const now = Date.now();
         const session = {
             id: `route-${randomUUID()}`,
+            kind: 'channel',
             channelId,
             userId,
             companionId: companion.id,
@@ -469,6 +615,7 @@ export class PartnerAgentRuntime {
         }
         const live = this.ctx.agents.get(route.sessionId);
         if (live !== undefined) {
+            await this.ensureRestoredComposition(live, companion, route, profile);
             await this.attachSession(companion, route);
             if (profile)
                 this.injectProfileUpdate(live, route.sessionId, profile);
@@ -483,7 +630,7 @@ export class PartnerAgentRuntime {
             agentCtx.systemPrompt.section({
                 name: 'partner-identity',
                 order: -10,
-                text: renderPersona(companion),
+                text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation'),
             });
             agentCtx.systemPrompt.section({
                 name: 'partner-tool-routing',
@@ -496,6 +643,7 @@ export class PartnerAgentRuntime {
                     order: -8,
                     text: renderProfile(profile),
                 });
+            await this.composer?.compose(agentCtx, companion);
         };
         let handle;
         try {
@@ -522,6 +670,68 @@ export class PartnerAgentRuntime {
         await this.attachSession(companion, route);
         return handle.agent;
     }
+    async ensureRestoredComposition(agent, companion, route, profile) {
+        const installed = this.restoredCompositions.get(route.sessionId);
+        if (installed?.agent === agent)
+            return;
+        const pending = this.restoredCompositionJobs.get(route.sessionId);
+        if (pending !== undefined)
+            return pending;
+        const job = this.composeRestoredAgent(agent, companion, route, profile);
+        this.restoredCompositionJobs.set(route.sessionId, job);
+        try {
+            await job;
+        }
+        finally {
+            if (this.restoredCompositionJobs.get(route.sessionId) === job)
+                this.restoredCompositionJobs.delete(route.sessionId);
+        }
+    }
+    async composeRestoredAgent(agent, companion, route, profile) {
+        await agent.whenIdle();
+        let dispose;
+        await agent.runMaintenance(async (signal) => {
+            if (signal.aborted)
+                throw signal.reason;
+            const agentCtx = agent.ctx;
+            const key = scopeOf(agentCtx);
+            if (key === undefined)
+                throw new Error('伙伴会话缺少 Agent 作用域');
+            if (scopeParentOf(key) === undefined) {
+                const presets = agentCtx.get('agentPresets');
+                if (presets === undefined)
+                    throw new Error('伙伴会话缺少 Agent Presets 服务');
+                await presets.mount(agentCtx, companion.presetId);
+            }
+            const disposers = [];
+            try {
+                disposers.push(agentCtx.systemPrompt.section({ name: 'partner-identity', order: -10, text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation') }));
+                disposers.push(agentCtx.systemPrompt.section({ name: 'partner-tool-routing', order: -9, text: renderToolProtocol() }));
+                if (profile && profile.entries.length > 0)
+                    disposers.push(agentCtx.systemPrompt.section({ name: 'partner-user-profile', order: -8, text: renderProfile(profile) }));
+                if (this.composer)
+                    disposers.push(await this.composer.compose(agentCtx, companion));
+            }
+            catch (error) {
+                for (let index = disposers.length - 1; index >= 0; index -= 1)
+                    disposers[index]?.();
+                throw error;
+            }
+            let disposed = false;
+            dispose = () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                for (let index = disposers.length - 1; index >= 0; index -= 1)
+                    disposers[index]?.();
+            };
+        });
+        if (dispose === undefined)
+            throw new Error('伙伴会话恢复组合未完成');
+        const previous = this.restoredCompositions.get(route.sessionId);
+        previous?.dispose();
+        this.restoredCompositions.set(route.sessionId, { agent, dispose });
+    }
     injectProfileUpdate(agent, sessionId, profile) {
         const previous = this.profileVersions.get(sessionId);
         if (previous === profile.version)
@@ -544,6 +754,21 @@ export class PartnerAgentRuntime {
         await (await workspace).attachSession(route.sessionId);
     }
 }
+const TASK_PROGRESS_NOTICE_SUMMARIES = ['看板任务待验收', '看板任务已完成', '看板任务受阻'];
+function taskProgressNoticeSummary(status) {
+    if (status === 'review')
+        return '看板任务待验收';
+    if (status === 'done')
+        return '看板任务已完成';
+    return '看板任务受阻';
+}
+export function selectTaskNotificationRoute(routes, creatorSessionId, archived) {
+    const available = routes.filter(route => !archived(route));
+    return available.find(route => route.sessionId === creatorSessionId)
+        ?? available.filter(route => route.kind === 'channel').sort((left, right) => right.lastMessageAt - left.lastMessageAt)[0]
+        ?? available.find(route => route.kind === 'local')
+        ?? available.sort((left, right) => right.lastMessageAt - left.lastMessageAt)[0];
+}
 function delay(milliseconds) {
     return new Promise(resolve => setTimeout(resolve, milliseconds));
 }
@@ -660,13 +885,6 @@ function renderDeferredMentions(entries) {
         ...entries.map(item => `- ${item.event}${item.evidence ? `（依据：${item.evidence}）` : ''}`),
     ].join('\n');
 }
-export function resolveAgentOptions(defaultModel, companion) {
-    return {
-        ...defaultModel.currentSelection(),
-        ...(companion.provider ? { provider: companion.provider } : {}),
-        ...(companion.model ? { model: companion.model } : {}),
-    };
-}
 export function canReuseSession(route, companionId, archivedSessionIds) {
     return route.companionId === companionId && !archivedSessionIds.includes(route.sessionId);
 }
@@ -750,7 +968,7 @@ async function runHeartbeatInference(ctx, agent, companion, concerns, signal) {
             for await (const chunk of prepared.stream({
                 ...prepared.config,
                 messages,
-                system: renderPersona(companion, 'heartbeat'),
+                system: renderPartnerPersona(companion, 'heartbeat'),
                 tools: discoveryOpen ? tools : [],
                 signal,
             }))
@@ -1001,42 +1219,6 @@ function formatDuration(milliseconds) {
     return `${(milliseconds / 1_000).toFixed(milliseconds < 10_000 ? 1 : 0)} 秒`;
 }
 function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
-function renderPersona(companion, surface = 'conversation') {
-    const capabilities = companion.capabilities.length > 0 ? companion.capabilities.join('、') : '由当前 Agent Preset 提供的基础能力';
-    return [
-        `你当前以长期工作伙伴「${companion.name}」的身份工作。`,
-        `角色：${companion.role}`,
-        companion.description ? `定位：${companion.description}` : '',
-        companion.instructions ? `长期行为准则：\n${companion.instructions}` : '',
-        `用户为此伙伴启用的能力范围：${capabilities}。能力标识不等于授权；只能调用当前会话实际提供且已经通过权限校验的工具。`,
-        surface === 'heartbeat'
-            ? '这是一轮独立的伙伴心跳，不是用户聊天的延续。只根据本轮真实可读信息行动，最终结果由渠道适配器决定是否发送。'
-            : '这个会话由 DSH 网页与微信私聊渠道共同使用。保持同一上下文，不要假定每条消息都来自微信；渠道回传由适配器负责。回答兼顾网页与移动端阅读，执行外部操作前继续遵守工具自身的授权与审批边界。',
-    ].filter(Boolean).join('\n\n');
-}
-export function renderToolProtocol() {
-    return [
-        'DSH 工具调用协议（必须遵守）：工具 SDK 中出现某项能力，不代表它可以作为顶层函数直接调用。',
-        '先以当前请求真正暴露的顶层工具清单为准。若顶层只提供 `run_code`，则它是唯一允许直接调用的工具；`web_search`、知识库、SSH 等 SDK 能力必须放进 `run_code` 程序，通过生成的 `tools` SDK 按准确签名调用，例如 `await tools.web_search(...)`。绝不要直接发起名为 `web_search` 的顶层工具调用。',
-        '`run_code` 的程序只返回完成当前任务所需的精简结果。需要顺序依赖时逐个 `await`，互不依赖的只读调用才可并行。',
-        '若工具结果提示 “only `run_code` is callable directly”，说明路由方式错误；立即在同一轮改用 `run_code` 重试。只有规范重试也失败时，才向用户说明真正的失败原因。',
-        '若当前请求原生暴露了目标工具，则可以直接调用该原生工具；不要臆造未出现在顶层清单或生成 SDK 中的工具。',
-        '需要把生成的图片或文档交给用户时，最终回复必须用 Markdown 链接明确引用伙伴工作目录中的文件，例如 `[下载文件](/绝对路径/文件.pdf)`；不要只说“文件在这里”。渠道会在确认真实路径位于伙伴工作目录后发送附件。',
-    ].join('\n');
-}
-function extractAssistantText(agent, fromSeq) {
-    const messages = [];
-    for (const event of agent.session.events) {
-        if (event.seq < fromSeq || event.type !== 'assistant/message' || event.data.interrupted)
-            continue;
-        const text = event.data.message.content
-            .filter((block) => block.type === 'text')
-            .map(block => block.text.trim()).filter(Boolean).join('\n');
-        if (text)
-            messages.push(text);
-    }
-    return messages.join('\n\n').trim();
-}
 function textContent(content) {
     return content.filter((block) => block.type === 'text' && typeof block.text === 'string')
         .map(block => block.text.trim()).filter(Boolean).join('\n');