@cicctencent/agent-server 0.2.81 → 0.2.83

package/dist/cjs/agent/agent-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-server.d.ts","sourceRoot":"","sources":["../../../src/agent/agent-server.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAMnB,MAAM,aAAa,CAAC;AA+BrB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAm4C1E"}
+{"version":3,"file":"agent-server.d.ts","sourceRoot":"","sources":["../../../src/agent/agent-server.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAMnB,MAAM,aAAa,CAAC;AA6ErB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAy9C1E"}

package/dist/cjs/agent/agent-server.js

@@ -23,6 +23,53 @@ const cache_service_ts_1 = require("../service/cache.service.js");
 const data_dir_ts_1 = require("../utils/data-dir.js");
 const env_collector_ts_1 = require("../service/env-collector.js");
 const interaction_service_ts_1 = require("../service/interaction.service.js");
+/**
+ * 子 Agent 事件全局去重包装器。
+ *
+ * 远程 A2A 服务（REST / JSON-RPC）有时会把同一事件重复下发——例如重复下发同一
+ * toolCallId 的 tool_call（导致前端出现「两张相同的工具卡片」），或重复下发
+ * start / done。这里按事件 key 在整条事件流生命周期内去重：
+ *   - tool_call / tool_result：key = `${type}:${toolCallId}`（同一调用只转发一次）
+ *   - start / done：key = `${type}:${parentToolCallId}`（每个父调用只一次）
+ *   - content / thinking / progress：相邻去重（避免逐段重复下发，前端另有累计增量兜底）
+ *
+ * 既挡住顶层的重复 tool_call 卡片，也避免重复事件污染 fullContent / toolCallCount 等
+ * 聚合状态。
+ *
+ * @param emit 底层 SubAgentEventEmitter（通常是 ctx.emitSubEvent）
+ * @param getKeyContext 提供 parentToolCallId / agentName 的回调（用于 start/done 去重）
+ */
+function dedupeSubEventEmitter(emit, getKeyContext) {
+    const seenGlobal = new Set();
+    let lastAdjKey = null;
+    return (evt) => {
+        const { eventType, data } = evt;
+        let dedupKey = null;
+        if (eventType === 'tool_call' || eventType === 'tool_result') {
+            const id = data?.toolCallId || data?.callId;
+            if (id)
+                dedupKey = `${eventType}:${id}`;
+        }
+        else if (eventType === 'start' || eventType === 'done') {
+            const ctx = getKeyContext();
+            dedupKey = `${eventType}:${ctx.parentToolCallId}`;
+        }
+        else if (eventType === 'content' || eventType === 'thinking' || eventType === 'progress') {
+            // 相邻去重：同一文本连续下发则跳过（避免逐段叠加噪声）
+            const text = eventType === 'progress' ? JSON.stringify(data ?? {}) : (data?.content || '');
+            const adjKey = `${eventType}:${text}`;
+            if (adjKey === lastAdjKey)
+                return;
+            lastAdjKey = adjKey;
+        }
+        if (dedupKey) {
+            if (seenGlobal.has(dedupKey))
+                return;
+            seenGlobal.add(dedupKey);
+        }
+        emit?.(evt);
+    };
+}
 /**
  * 远程 Agent A2A 调试槽（per-request）。
  * 委派远程 Agent 的 runner 在引擎 build 期创建并缓存，运行时无法持有具体请求的
@@ -137,12 +184,21 @@ function createAgentServer(options) {
         toolRegistry.register(askUserTool);
         toolRegistry.registerAll([...builtinTools, ...extraTools]);
         skillManager = new agent_core_1.SkillManager();
-        const skillsDir = options.skillsDir || process.env.SKILLS_DIR || './data/skills';
-        try {
-            skillManager.loadFromDir(skillsDir, 'system');
+        if (options.skills?.length) {
+            // DB 源：直接注入 Skills（以 name 为唯一标识，更扁平，不依赖文件路径）
+            for (const s of options.skills) {
+                skillManager.register(s);
+            }
+            console.log(`[AgentServer] 已从注入源加载 ${options.skills.length} 个 Skills`);
         }
-        catch (e) {
-            console.warn('[AgentServer] Failed to load skills from', skillsDir, e);
+        else {
+            const skillsDir = options.skillsDir || process.env.SKILLS_DIR || './data/skills';
+            try {
+                skillManager.loadFromDir(skillsDir, 'system');
+            }
+            catch (e) {
+                console.warn('[AgentServer] Failed to load skills from', skillsDir, e);
+            }
         }
         contextManager = new agent_core_1.ContextManager();
         const securityGuard = new agent_core_1.SecurityGuard();
@@ -227,8 +283,11 @@ function createAgentServer(options) {
     async function buildEngineForProfile(numericProfileId, profileOverride, skipCache, tenant, cacheKey, isSubAgent = false, allowedSpecialistIds, sessionId, canDelegateOverride) {
         const { toolRegistry: baseRegistry, skillManager: baseSkillManager, contextManager: ctxManager } = getAgentSystem();
         const profile = profileOverride || (numericProfileId ? await agentProfileProvider.getProfile(numericProfileId, tenant) : await agentProfileProvider.getDefaultProfile(tenant));
-        if (!profile)
-            return engine;
+        if (!profile) {
+            throw new Error(numericProfileId
+                ? `Agent profile not found: ${numericProfileId}`
+                : 'Default agent profile not found');
+        }
         // canDelegate: 非 remote Agent 均可委派子任务（BI 项目不依赖 isDefault 字段）
         const agentToolRegistry = new agent_core_1.ToolRegistry();
         baseRegistry.getDefinitions().forEach(def => {
@@ -316,12 +375,17 @@ function createAgentServer(options) {
                                 scope: sp.scope,
                                 keywords: sp.keywords,
                                 exclusiveScope: sp.exclusiveScope,
+                                // 该子 Agent 自身的委派超时（来自 Fdelegate_timeout_ms），覆盖全局默认。
+                                // 注：AgentProfileProvider.listProfiles 已在源头把未配置（0/null）归一化为
+                                // undefined，此处 || undefined 为防御性兜底（防止其它未归一化的 provider 传入 0
+                                // 被 `?? timeoutMs` 保留为 0 并当作 falsy → 完全不加超时）。
+                                timeoutMs: sp.delegateTimeoutMs || undefined,
                                 run: async (task, _ctx, _runOptions) => {
                                     // 从 ToolContext 中提取父会话 ID（用于建立父子关系，
                                     // 使 RateLimitManager 能在父会话 abort 时终止子会话）
                                     const parentSessionId = _ctx?.sessionId;
                                     const parentCallId = (_ctx?.currentToolCallId ?? _ctx?.callId);
-                                    const emit = _ctx?.emitSubEvent;
+                                    const emit = dedupeSubEventEmitter(_ctx?.emitSubEvent, () => ({ parentToolCallId: parentCallId ?? '', agentName: sp.name }));
                                     // 部分结果注入回调：子 Agent 流式输出时实时注入主 Agent 历史
                                     const injectPartialResult = _ctx?.injectPartialResult;
                                     const subSessionId = `sub_${sp.id}_${Date.now()}`;
@@ -673,38 +737,46 @@ function createAgentServer(options) {
     const waA2AClientPool = new Map();
     function waClientForKey(kind, profile) {
         const auth = profile.remoteAuth?.value ? { t: profile.remoteAuth.type, n: profile.remoteAuth.name } : null;
-        return `${kind}|${JSON.stringify({ auth, h: buildExtraHeaders(profile.remoteAuth) })}`;
+        const t = a2aEffectiveTimeouts(profile);
+        return `${kind}|${JSON.stringify({ auth, h: buildExtraHeaders(profile.remoteAuth), t })}`;
+    }
+    /** 解析 Profile 上的 A2A 超时配置（带默认值），0/未设置回退到默认值 */
+    function a2aEffectiveTimeouts(profile) {
+        return {
+            timeout: profile.a2aTimeout || 300_000,
+            connectTimeout: profile.a2aConnectTimeout || 30_000,
+            chunkTimeout: profile.a2aChunkTimeout || 60_000,
+        };
+    }
+    /** 按 profile 构造 A2A/REST 客户端配置：profile 自身的 A2A 超时优先，缺省走 A2AClient 默认 */
+    function buildA2AClientOpts(profile, onDebugTrace) {
+        const t = a2aEffectiveTimeouts(profile);
+        const opts = {
+            timeout: t.timeout,
+            connectTimeout: t.connectTimeout,
+            chunkTimeout: t.chunkTimeout,
+        };
+        if (profile.remoteAuth?.value) {
+            opts.auth = { type: profile.remoteAuth.type, value: profile.remoteAuth.value, name: profile.remoteAuth.name };
+            opts.headers = buildExtraHeaders(profile.remoteAuth);
+        }
+        else if (profile.remoteAuth?.extraHeaders?.length) {
+            opts.headers = buildExtraHeaders(profile.remoteAuth);
+        }
+        if (onDebugTrace)
+            opts.onDebugTrace = onDebugTrace;
+        return opts;
     }
     function getWaRestClient(profile, onDebugTrace) {
         // debug trace handler 是 per-run 回调，不能池化，否则会复用旧 handler 导致调试 trace 串流
         if (onDebugTrace) {
-            let opts;
-            if (profile.remoteAuth?.value) {
-                opts = { timeout: 300_000, auth: { type: profile.remoteAuth.type, value: profile.remoteAuth.value, name: profile.remoteAuth.name }, headers: buildExtraHeaders(profile.remoteAuth), onDebugTrace };
-            }
-            else if (profile.remoteAuth?.extraHeaders?.length) {
-                opts = { timeout: 300_000, headers: buildExtraHeaders(profile.remoteAuth), onDebugTrace };
-            }
-            else {
-                opts = { timeout: 300_000, onDebugTrace };
-            }
-            return new agent_core_1.RestA2AClient(opts);
+            return new agent_core_1.RestA2AClient(buildA2AClientOpts(profile, onDebugTrace));
         }
         const key = waClientForKey('rest', profile);
         const hit = waRestClientPool.get(key);
         if (hit && Date.now() - hit.ts < WA_CLIENT_POOL_TTL)
             return hit.client;
-        let opts;
-        if (profile.remoteAuth?.value) {
-            opts = { timeout: 300_000, auth: { type: profile.remoteAuth.type, value: profile.remoteAuth.value, name: profile.remoteAuth.name }, headers: buildExtraHeaders(profile.remoteAuth) };
-        }
-        else if (profile.remoteAuth?.extraHeaders?.length) {
-            opts = { timeout: 300_000, headers: buildExtraHeaders(profile.remoteAuth) };
-        }
-        else {
-            opts = { timeout: 300_000 };
-        }
-        const client = new agent_core_1.RestA2AClient(opts);
+        const client = new agent_core_1.RestA2AClient(buildA2AClientOpts(profile));
         waRestClientPool.set(key, { client, ts: Date.now() });
         if (waRestClientPool.size > 100)
             for (const [k, v] of waRestClientPool)
@@ -715,33 +787,13 @@ function createAgentServer(options) {
     function getWaA2AClient(profile, onDebugTrace) {
         // debug trace handler 是 per-run 回调，不能池化，否则会复用旧 handler 导致调试 trace 串流
         if (onDebugTrace) {
-            let opts;
-            if (profile.remoteAuth?.value) {
-                opts = { timeout: 300_000, auth: { type: profile.remoteAuth.type, value: profile.remoteAuth.value, name: profile.remoteAuth.name }, headers: buildExtraHeaders(profile.remoteAuth), onDebugTrace };
-            }
-            else if (profile.remoteAuth?.extraHeaders?.length) {
-                opts = { timeout: 300_000, headers: buildExtraHeaders(profile.remoteAuth), onDebugTrace };
-            }
-            else {
-                opts = { timeout: 300_000, onDebugTrace };
-            }
-            return new agent_core_1.A2AClient(opts);
+            return new agent_core_1.A2AClient(buildA2AClientOpts(profile, onDebugTrace));
         }
         const key = waClientForKey('a2a', profile);
         const hit = waA2AClientPool.get(key);
         if (hit && Date.now() - hit.ts < WA_CLIENT_POOL_TTL)
             return hit.client;
-        let opts;
-        if (profile.remoteAuth?.value) {
-            opts = { timeout: 300_000, auth: { type: profile.remoteAuth.type, value: profile.remoteAuth.value, name: profile.remoteAuth.name }, headers: buildExtraHeaders(profile.remoteAuth) };
-        }
-        else if (profile.remoteAuth?.extraHeaders?.length) {
-            opts = { timeout: 300_000, headers: buildExtraHeaders(profile.remoteAuth) };
-        }
-        else {
-            opts = { timeout: 300_000 };
-        }
-        const client = new agent_core_1.A2AClient(opts);
+        const client = new agent_core_1.A2AClient(buildA2AClientOpts(profile));
         waA2AClientPool.set(key, { client, ts: Date.now() });
         if (waA2AClientPool.size > 100)
             for (const [k, v] of waA2AClientPool)
@@ -750,6 +802,10 @@ function createAgentServer(options) {
         return client;
     }
     function createRemoteRunnerFromProfile(profile, onDebugTrace) {
+        // 委派超时优先级：agent 自身配置（Fdelegate_timeout_ms）> 远程 agent 自身 A2A 超时（Fa2a_timeout）> 全局默认。
+        // 用 || 而非 ??：provider 会在源头把未配置（0/null）归一化为 undefined，但此处仍用 || 兜底，
+        // 把任何残留的 0 视为「未设置」逐级回退，最终 undefined 时由 delegate 工具回退到全局默认。
+        const runnerTimeoutMs = profile.delegateTimeoutMs || profile.a2aTimeout || undefined;
         // REST 风格 A2A
         if (profile.a2aProtocol === 'rest') {
             const restConfig = profile.restA2AConfig;
@@ -757,7 +813,7 @@ function createAgentServer(options) {
                 throw new Error(`REST A2A profile '${profile.name}' missing capabilityId in restA2AConfig`);
             }
             const restClient = getWaRestClient(profile, onDebugTrace);
-            return (0, agent_core_1.createRestA2ARemoteRunner)({
+            const runner = (0, agent_core_1.createRestA2ARemoteRunner)({
                 baseUrl: profile.remoteUrl,
                 capabilityId: restConfig.capabilityId,
                 name: `[Remote] ${profile.name}`,
@@ -770,7 +826,11 @@ function createAgentServer(options) {
                 fallbackToSync: restConfig.fallbackToSync,
                 streamAction: restConfig.streamAction,
                 invokeAction: restConfig.invokeAction,
+                // 透传输出模式：merge=完整内容回传主 Agent；panel=仅回传、完整内容保留在子面板
+                outputMode: profile.a2aOutputMode || 'merge',
             });
+            runner.timeoutMs = runnerTimeoutMs;
+            return runner;
         }
         // 标准 JSON-RPC A2A（默认）
         const agentUrl = profile.remoteCard?.url || profile.remoteUrl;
@@ -778,21 +838,27 @@ function createAgentServer(options) {
             throw new Error(`Remote profile '${profile.name}' missing remoteUrl`);
         }
         let agentClient;
+        const hasCustomA2ATimeout = !!(profile.a2aTimeout || profile.a2aConnectTimeout || profile.a2aChunkTimeout);
         // 调试模式（onDebugTrace 非空）下不能用共享 options.a2aClient--它未注入 handler，
         // 会导致 A2A 请求 trace 永不触发；改用 getWaA2AClient 创建带 handler 的客户端。
-        if (options.a2aClient && !onDebugTrace) {
+        // profile 配置了自定义 A2A 超时时也必须走 getWaA2AClient（共享 client 写死 300_000，无法按 profile 覆盖）。
+        if (options.a2aClient && !onDebugTrace && !hasCustomA2ATimeout) {
             agentClient = options.a2aClient;
         }
         else {
             agentClient = getWaA2AClient(profile, onDebugTrace);
         }
-        return (0, agent_core_1.createA2ARemoteRunner)({
+        const runner = (0, agent_core_1.createA2ARemoteRunner)({
             agentUrl,
             name: `[Remote] ${profile.name}`,
             description: profile.description || profile.domain || 'Remote specialist agent',
             streaming: true,
             client: agentClient,
+            // 透传输出模式：merge=完整内容回传主 Agent；panel=仅回传、完整内容保留在子面板
+            outputMode: profile.a2aOutputMode || 'merge',
         });
+        runner.timeoutMs = runnerTimeoutMs;
+        return runner;
     }
     /**
      * 运行远程 Agent（直接通过 A2A 协议与远程端点通信，不初始化本地引擎）
@@ -887,7 +953,10 @@ function createAgentServer(options) {
         };
         // 确保 abortSignal 始终有值（runner 依赖 ctx.abortSignal 进行中止控制）
         const effectiveAbortSignal = abortSignal ?? new AbortController().signal;
-        const mockCtx = { currentToolCallId: parentCallId, abortSignal: effectiveAbortSignal, emitSubEvent };
+        // 包裹全局去重层：远程 A2A 服务重复下发的 tool_call / start / done 在源头被挡掉，
+        // 避免前端出现重复的工具卡片与进度噪声。
+        const dedupedEmitSubEvent = dedupeSubEventEmitter(emitSubEvent, () => ({ parentToolCallId: parentCallId, agentName: profile.name }));
+        const mockCtx = { currentToolCallId: parentCallId, abortSignal: effectiveAbortSignal, emitSubEvent: dedupedEmitSubEvent };
         console.log(`[AgentServer] Remote agent stream: profile=${profile.name}(${profile.id}), url=${profile.remoteUrl}, protocol=${profile.a2aProtocol || 'json-rpc'}`);
         try {
             const result = await runner.run(messageText, mockCtx, {});
@@ -1039,6 +1108,10 @@ function createAgentServer(options) {
         catch (err) {
             console.warn('[AgentServer] Memory recall failed:', err?.message);
         }
+        // panel 模式追踪：记录哪些子 Agent 调用已进入摘要模式
+        const subAgentSummaryActive = new Set();
+        const subAgentContentMap = new Map();
+        const subAgentMainRelayed = new Set();
         const emitSubEvent = (evt) => {
             // 子 Agent 的 interaction_request 事件需要特殊处理，转发为顶层 interaction-request
             if (evt.eventType === 'interaction_request') {
@@ -1058,7 +1131,52 @@ function createAgentServer(options) {
                 });
             }
             else {
+                // 始终转发到子 Agent 面板（sub-agent 事件供前端构建子面板卡片）
                 registry.addEvent(threadIdNum, 'sub-agent', evt);
+                // ── panel 模式逻辑 ──
+                // 远程/子 Agent 在 start 事件声明 outputMode='panel' 时进入摘要模式：
+                // 此后其原始 content 不再 relay 进主气泡（原文留在 sub-agent 面板），
+                // 主气泡改由 kind=summary 的 content 或 summary(mode=final) 事件填充。
+                if (evt.eventType === 'start' && evt.data?.outputMode === 'panel') {
+                    subAgentSummaryActive.add(evt.parentToolCallId);
+                }
+                // content 事件：panel 模式下抑制过程性内容，仅 kind=summary 进主气泡
+                if (evt.eventType === 'content' && typeof evt.data?.content === 'string' && evt.data.content) {
+                    const current = evt.data.content;
+                    const isFirst = !subAgentContentMap.has(evt.parentToolCallId);
+                    const prev = subAgentContentMap.get(evt.parentToolCallId) ?? '';
+                    // 累积式内容（本地 specialist）：current 以 prev 为前缀且更长 -> 取后缀
+                    // 增量式内容（远程 A2A）：直接用作 delta
+                    const delta = (prev.length > 0 && current.length > prev.length && current.startsWith(prev))
+                        ? current.slice(prev.length)
+                        : current;
+                    subAgentContentMap.set(evt.parentToolCallId, prev + delta);
+                    if ((!subAgentSummaryActive.has(evt.parentToolCallId) || evt.data?.kind === 'summary') && delta) {
+                        const prefix = isFirst ? '\n\n' : '';
+                        registry.addEvent(threadIdNum, 'content', prefix + delta);
+                        subAgentMainRelayed.add(evt.parentToolCallId);
+                    }
+                }
+                // summary 事件：mode='final' 写入主气泡作为"分析结论"
+                if (evt.eventType === 'summary' && typeof evt.data?.content === 'string' && evt.data.content) {
+                    subAgentSummaryActive.add(evt.parentToolCallId);
+                    const mode = evt.data.mode || 'replace';
+                    if (mode === 'final') {
+                        const isFirstMain = !subAgentMainRelayed.has(evt.parentToolCallId);
+                        const prefix = isFirstMain ? '\n\n' : '';
+                        registry.addEvent(threadIdNum, 'content', prefix + evt.data.content);
+                        subAgentMainRelayed.add(evt.parentToolCallId);
+                    }
+                }
+                // done/error：清理追踪 + 尾部分隔
+                if (evt.eventType === 'done' || evt.eventType === 'error') {
+                    if (subAgentMainRelayed.has(evt.parentToolCallId)) {
+                        registry.addEvent(threadIdNum, 'content', '\n\n');
+                        subAgentMainRelayed.delete(evt.parentToolCallId);
+                    }
+                    subAgentContentMap.delete(evt.parentToolCallId);
+                    subAgentSummaryActive.delete(evt.parentToolCallId);
+                }
             }
         };
         customContext.emitSubEvent = emitSubEvent;