Claude Code内置Sub-Agent原理深度解析：多代理协作架构的工程实现

// loadAgentsDir.ts
export type AgentDefinition =
  | BuiltInAgentDefinition    // 内置 Agent
  | CustomAgentDefinition     // 自定义 Agent
  | PluginAgentDefinition     // 插件 Agent

export type BuiltInAgentDefinition = BaseAgentDefinition & {
  source: 'built-in'
  baseDir: 'built-in'
  callback?: () => void
  getSystemPrompt: (params: {
    toolUseContext: Pick<ToolUseContext, 'options'>
  }) => string
}

export type CustomAgentDefinition = BaseAgentDefinition & {
  getSystemPrompt: () => string
  source: SettingSource  // userSettings / projectSettings / policySettings / flagSettings
  filename?: string
  baseDir?: string
}

export type PluginAgentDefinition = BaseAgentDefinition & {
  getSystemPrompt: () => string
  source: 'plugin'
  filename?: string
  plugin: string
}

export type BaseAgentDefinition = {
  agentType: string              // Agent 类型标识
  whenToUse: string              // 使用场景描述（展示给主 Agent）
  tools?: string[]               // 允许的工具列表（'*' 表示全部）
  disallowedTools?: string[]     // 禁止的工具列表
  skills?: string[]              // 预加载的 Skill 名称
  mcpServers?: AgentMcpServerSpec[]  // Agent 专属 MCP 服务器
  hooks?: HooksSettings          // Session 级 Hooks
  color?: AgentColorName         // UI 颜色标识
  model?: string                 // 模型选择（支持 'inherit'）
  effort?: EffortValue           // 推理努力等级
  permissionMode?: PermissionMode // 权限模式
  maxTurns?: number              // 最大对话轮数
  background?: boolean           // 是否强制后台运行
  memory?: AgentMemoryScope      // 持久内存作用域
  isolation?: 'worktree' | 'remote'  // 隔离模式
  omitClaudeMd?: boolean         // 是否省略 CLAUDE.md
  // ...
}

// loadAgentsDir.ts
const agentGroups = [
  builtInAgents,    // 最低优先级
  pluginAgents,
  userAgents,       // ~/.claude/agents/*.md
  projectAgents,    // .claude/agents/*.md
  flagAgents,       // GrowthBook 远程配置
  managedAgents,    // 最高优先级（policy settings）
]

const agentMap = new Map<string, AgentDefinition>()
for (const agents of agentGroups) {
  for (const agent of agents) {
    agentMap.set(agent.agentType, agent)  // 后者覆盖前者
  }
}

export function getBuiltInAgents(): AgentDefinition[] {
  const agents: AgentDefinition[] = [
    GENERAL_PURPOSE_AGENT,      // 始终启用
    STATUSLINE_SETUP_AGENT,     // 始终启用
  ]

  if (areExplorePlanAgentsEnabled()) {
    agents.push(EXPLORE_AGENT, PLAN_AGENT)  // Feature flag 控制
  }

  if (isNonSdkEntrypoint) {
    agents.push(CLAUDE_CODE_GUIDE_AGENT)     // 非 SDK 入口时启用
  }

  if (feature('VERIFICATION_AGENT') && 
      getFeatureValue_CACHED_MAY_BE_STALE('tengu_hive_evidence', false)) {
    agents.push(VERIFICATION_AGENT)           // Feature flag + GrowthBook 控制
  }

  return agents
}

// generalPurposeAgent.ts
export const GENERAL_PURPOSE_AGENT: BuiltInAgentDefinition = {
  agentType: 'general-purpose',
  whenToUse: 'General-purpose agent for researching complex questions, searching for code...',
  tools: ['*'],
  source: 'built-in',
  baseDir: 'built-in',
  getSystemPrompt: getGeneralPurposeSystemPrompt,
}

getSystemPrompt({ toolUseContext }) {
  const commands = toolUseContext.options.commands
  const contextSections: string[] = []

  // 1. 注入自定义 Skills
  const customCommands = commands.filter(cmd => cmd.type === 'prompt')
  if (customCommands.length > 0) {
    contextSections.push(`**Available custom skills:**\n${commandList}`)
  }
  // 2. 注入自定义 Agents
  // 3. 注入 MCP 服务器
  // 4. 注入用户设置
  // ...
}

{
  description: string,         // 3-5 字简短描述
  prompt: string,              // 任务提示
  subagent_type?: string,      // Agent 类型（可选）
  model?: 'sonnet'|'opus'|'haiku',  // 模型覆盖
  run_in_background?: boolean, // 后台运行
  name?: string,               // Agent 名称（用于 SendMessage 路由）
  isolation?: 'worktree'|'remote', // 隔离模式
}

// AgentTool.tsx
const effectiveType = subagent_type 
  ?? (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType)

const isForkPath = effectiveType === undefined

// 1. 从活跃 Agent 列表中过滤被权限规则拒绝的
const agents = filterDeniedAgents(allAgents, toolPermissionContext, AGENT_TOOL_NAME)

// 2. 查找目标 Agent
const found = agents.find(agent => agent.agentType === effectiveType)

// 3. 如果不存在但被权限拒绝，给出明确错误
if (agentExistsButDenied) {
  throw new Error(`Agent type '${effectiveType}' has been denied by permission rule...`)
}

// 4. 等待 MCP 服务器就绪（最多 30 秒）
if (requiredMcpServers?.length) {
  // ... 轮询等待 MCP 连接
}

// AgentTool.tsx
const workerPermissionContext = {
  ...appState.toolPermissionContext,
  mode: selectedAgent.permissionMode ?? 'acceptEdits'
}
const workerTools = assembleToolPool(workerPermissionContext, appState.mcp.tools)

if (isForkPath) {
  // Fork 路径：继承父代的已渲染系统提示（字节级一致！）
  forkParentSystemPrompt = toolUseContext.renderedSystemPrompt
  promptMessages = buildForkedMessages(prompt, assistantMessage)
} else {
  // 标准路径：使用 Agent 自己的 getSystemPrompt()
  const agentPrompt = selectedAgent.getSystemPrompt({ toolUseContext })
  enhancedSystemPrompt = await enhanceSystemPromptWithEnvDetails([agentPrompt], ...)
  promptMessages = [createUserMessage({ content: prompt })]
}

const shouldRunAsync = (
  run_in_background === true ||
  selectedAgent.background === true ||
  isCoordinator ||
  forceAsync ||              // Fork 实验：全部异步化
  assistantForceAsync ||     // KAIROS 模式
  proactiveModule?.isProactiveActive()
) && !isBackgroundTasksDisabled

// forkedAgent.ts — 三策略隔离模型
export function createSubagentContext(parentContext, overrides?) {
  return {
    // ===== 克隆（Clone）：避免交叉污染但保留初始状态 =====
    readFileState: cloneFileStateCache(overrides?.readFileState ?? parentContext.readFileState),
    // 关键：contentReplacementState 必须克隆而非新建！
    // 原因：fork 子代处理父消息中的 tool_use_id 时，
    // 如果是新建状态，会将这些 ID 视为"从未见过" → 做出不同的替换决策
    // → wire prefix 不同 → Prompt Cache miss
    // 克隆确保做出相同决策 → 相同的 wire prefix → Cache hit
    contentReplacementState: overrides?.contentReplacementState 
      ?? cloneContentReplacementState(parentContext.contentReplacementState),

    // ===== 新建（Fresh）：完全独立的实例 =====
    nestedMemoryAttachmentTriggers: new Set<string>(),
    discoveredSkillNames: new Set<string>(),
    localDenialTracking: createDenialTrackingState(), // 独立的拒绝追踪
    queryTracking: { chainId: randomUUID(), depth: parentDepth + 1 },

    // ===== No-op / 共享 =====
    setAppState: overrides?.shareSetAppState ? parentContext.setAppState : () => {},
    setAppStateForTasks: parentContext.setAppStateForTasks, // 始终共享！防止僵尸进程
    // UI 回调全部 undefined（子 Agent 无法控制父 UI）
    addNotification: undefined,
    setToolJSX: undefined,
  }
}

// abortController.ts — WeakRef 防止内存泄漏
export function createChildAbortController(parent) {
  const child = createAbortController(50) // maxListeners=50
  
  const weakChild = new WeakRef(child)   // 父不强持有子
  const weakParent = new WeakRef(parent) // 子不强持有父
  
  // 父 abort → 传播到子（单向）
  parent.signal.addEventListener('abort', 
    propagateAbort.bind(weakParent, weakChild), { once: true })
  
  // 子 abort → 清理父上的 listener（防止 handler 堆积）
  child.signal.addEventListener('abort',
    removeAbortHandler.bind(weakParent, new WeakRef(handler)), { once: true })
  
  return child // 子 abort 不影响父！
}

const agentGetAppState = () => {
  const state = toolUseContext.getAppState()
  
  // 1. permissionMode 覆盖 — 但最高权限级别不被降级
  if (agentPermissionMode &&
      state.mode !== 'bypassPermissions' &&  // 最高，不可降级
      state.mode !== 'acceptEdits' &&         // 次高，不可降级
      !(feature('TRANSCRIPT_CLASSIFIER') && state.mode === 'auto')) {
    toolPermissionContext = { ...toolPermissionContext, mode: agentPermissionMode }
  }

  // 2. shouldAvoidPrompts — bubble 模式的特殊行为
  //    bubble: 即使异步也显示提示（冒泡到父终端）
  //    非 bubble 异步: 隐避提示（auto-deny）
  const shouldAvoidPrompts = agentPermissionMode === 'bubble' ? false : isAsync

  // 3. awaitAutomatedChecksBeforeDialog
  //    后台 Agent 如果能显示提示，应先等待自动化检查完成，
  //    只在自动化检查无法解决时才中断用户
  if (isAsync && !shouldAvoidPrompts) {
    toolPermissionContext.awaitAutomatedChecksBeforeDialog = true
  }
}

function finalizeAgentTool(agentMessages, agentId, metadata) {
  // 提取最后一条 assistant 消息的文本内容
  const lastAssistantMessage = getLastAssistantMessage(agentMessages)
  let content = lastAssistantMessage.message.content.filter(_ => _.type === 'text')
  
  // 统计 token 使用和工具调用次数
  const totalTokens = getTokenCountFromUsage(lastAssistantMessage.message.usage)
  const totalToolUseCount = countToolUses(agentMessages)

  // 发送缓存驱逐提示
  logEvent('tengu_cache_eviction_hint', { scope: 'subagent_end', ... })

  return { agentId, agentType, content, totalDurationMs, totalTokens, totalToolUseCount, usage }
}

function isForkSubagentEnabled(): boolean {
  if (feature('FORK_SUBAGENT')) {
    if (isCoordinatorMode()) return false   // 与 Coordinator 互斥
    if (getIsNonInteractiveSession()) return false // 非交互会话不支持
    return true
  }
  return false
}

export function buildForkedMessages(
  directive: string,
  assistantMessage: AssistantMessage,
): MessageType[] {
  // 1. 克隆父代的完整 assistant 消息（保留所有 tool_use、thinking、text 块）
  const fullAssistantMessage = { ...assistantMessage, uuid: randomUUID(), ... }

  // 2. 为每个 tool_use 构建统一占位符 tool_result
  const toolResultBlocks = toolUseBlocks.map(block => ({
    type: 'tool_result',
    tool_use_id: block.id,
    content: [{ type: 'text', text: 'Fork started — processing in background' }]
  }))

  // 3. 构建单一 user 消息：占位符 results + 每子代独有指令
  const toolResultMessage = createUserMessage({
    content: [...toolResultBlocks, { type: 'text', text: buildChildMessage(directive) }]
  })

  return [fullAssistantMessage, toolResultMessage]
}

<fork-boilerplate>
STOP. READ THIS FIRST.
You are a forked worker process. You are NOT the main agent.

RULES (non-negotiable):
1. Do NOT spawn sub-agents; execute directly
2. Do NOT converse, ask questions
3. USE your tools directly
4. If you modify files, commit your changes
5. Keep report under 500 words
...
</fork-boilerplate>

FORK_DIRECTIVE: {directive}

// 方式一：检查 querySource（抗 autocompact）
if (toolUseContext.options.querySource === 'agent:builtin:fork') {
  throw new Error('Fork is not available inside a forked worker.')
}

// 方式二：消息内容扫描（备用）
function isInForkChild(messages: MessageType[]): boolean {
  return messages.some(m => {
    if (m.type !== 'user') return false
    return content.some(block =>
      block.type === 'text' && block.text.includes(`<fork-boilerplate>`)
    )
  })
}

function filterToolsForAgent({ tools, isBuiltIn, isAsync, permissionMode }) {
  return tools.filter(tool => {
    // MCP 工具始终放行
    if (tool.name.startsWith('mcp__')) return true
    
    // 全局禁止列表
    if (ALL_AGENT_DISALLOWED_TOOLS.has(tool.name)) return false
    
    // 自定义 Agent 额外禁止列表
    if (!isBuiltIn && CUSTOM_AGENT_DISALLOWED_TOOLS.has(tool.name)) return false
    
    // 异步 Agent 白名单过滤
    if (isAsync && !ASYNC_AGENT_ALLOWED_TOOLS.has(tool.name)) return false
    
    return true
  })
}

function resolveAgentTools(agentDefinition, availableTools, isAsync) {
  // 先应用第一层全局过滤
  const filteredAvailableTools = filterToolsForAgent(...)
  
  // 应用 disallowedTools 排除
  const allowedAvailableTools = filteredAvailableTools.filter(
    tool => !disallowedToolSet.has(tool.name)
  )

  // tools: ['*'] → 使用全部
  // tools: ['Read', 'Bash'] → 只包含列出的
  if (hasWildcard) return { resolvedTools: allowedAvailableTools }
  
  // 精确匹配
  for (const toolSpec of agentTools) {
    const tool = availableToolMap.get(toolName)
    if (tool) resolved.push(tool)
  }
}

// 解析 "Agent(worker, researcher)" 中的类型列表
if (toolName === AGENT_TOOL_NAME && ruleContent) {
  allowedAgentTypes = ruleContent.split(',').map(s => s.trim())
}

const resolvedTools = useExactTools
  ? availableTools  // 直接使用父代的精确工具池
  : resolveAgentTools(agentDefinition, availableTools, isAsync).resolvedTools

// runAgent.ts
const shouldAvoidPrompts =
  canShowPermissionPrompts !== undefined
    ? !canShowPermissionPrompts
    : agentPermissionMode === 'bubble'
      ? false   // bubble 模式：始终不隐避提示
      : isAsync  // 普通异步 Agent：隐避提示

if (allowedTools !== undefined) {
  toolPermissionContext = {
    ...toolPermissionContext,
    alwaysAllowRules: {
      cliArg: state.toolPermissionContext.alwaysAllowRules.cliArg, // 保留 SDK 级权限
      session: [...allowedTools], // 用提供的作为会话级权限
    },
  }
}

if (agentModelWithExp === 'inherit') {
  return getRuntimeMainLoopModel({
    permissionMode: permissionMode ?? 'default',
    mainLoopModel: parentModel,
    exceeds200kTokens: false,
  })
}

function aliasMatchesParentTier(alias: string, parentModel: string): boolean {
  const canonical = getCanonicalName(parentModel)
  switch (alias.toLowerCase()) {
    case 'opus':   return canonical.includes('opus')
    case 'sonnet': return canonical.includes('sonnet')
    case 'haiku':  return canonical.includes('haiku')
    default:       return false
  }
}

const shouldRunAsync = (
  run_in_background === true ||       // 明确请求
  selectedAgent.background === true || // Agent 定义标记
  isCoordinator ||                     // Coordinator 模式
  forceAsync ||                        // Fork 实验（全部异步化）
  assistantForceAsync ||               // KAIROS 模式
  proactiveModule?.isProactiveActive() // 主动模式
) && !isBackgroundTasksDisabled

// 注册时设置 120 秒自动背景化计时器
const registration = registerAgentForeground({
  agentId: syncAgentId,
  autoBackgroundMs: getAutoBackgroundMs() || undefined // 120秒
})

// 核心竞争循环
while (true) {
  const nextMessagePromise = agentIterator.next()
  
  // Promise.race：消息 vs 背景化信号
  const raceResult = await Promise.race([
    nextMessagePromise.then(r => ({ type: 'message', result: r })),
    backgroundPromise  // 背景化信号（用户 ESC 或 120 秒超时）
  ])

  if (raceResult.type === 'background') {
    wasBackgrounded = true
    
    // 关键步骤 1：清理前台 async iterator
    // agentIterator.return() 触发 runAgent() 的 finally block
    // 释放 MCP 连接、session hooks、prompt cache tracking 等
    // 1 秒超时保护 + .catch() 防止未处理 rejection
    await Promise.race([
      agentIterator.return(undefined).catch(() => {}),
      sleep(1000)
    ])

    // 关键步骤 2：启动新的后台流
    void runWithAgentContext(syncAgentContext, async () => {
      // 回放已收集的消息到新的 progress tracker
      for (const existingMsg of agentMessages) {
        updateProgressFromMessage(tracker, existingMsg, ...)
      }
      // 使用正确的 agentId 和 task 自己的 abortController 创建新流
      // 注意：abortController 不链接到父代（后台 Agent 在用户 ESC 时存活）
      for await (const msg of runAgent({
        ...runAgentParams,
        isAsync: true,
        override: { agentId: backgroundedTaskId, abortController: task.abortController }
      })) { ... }
    })
    
    // 关键步骤 3：立即返回 async_launched 结果
    return { data: { status: 'async_launched', agentId: backgroundedTaskId } }
  }
}

// agentToolUtils.ts — 仅在 auto 模式下触发
async function classifyHandoffIfNeeded({ agentMessages, tools, ... }) {
  if (toolPermissionContext.mode !== 'auto') return null // 非 auto 模式跳过

  // 1. 构建紧凑的操作 transcript（不是完整消息体）
  const agentTranscript = buildTranscriptForClassifier(agentMessages, tools)
  // 格式：每条 tool_use → "toolName encodedInput\n"
  // 格式：每条 user text → "User: text\n"

  // 2. 调用 YOLO 分类器
  const classifierResult = await classifyYoloAction(agentMessages, {
    role: 'user',
    content: [{ type: 'text', 
      text: "Sub-agent has finished. Review the sub-agent's work based on block rules..." }]
  }, tools, toolPermissionContext, abortSignal)

  // 3. 结果处理
  if (classifierResult.unavailable)
    return "Note: Safety classifier was unavailable. Please carefully verify..."
  if (classifierResult.shouldBlock)
    return "SECURITY WARNING: This sub-agent performed actions that may violate security policy..."
  return null // 允许通过
}

function isCoordinatorMode(): boolean {
  if (feature('COORDINATOR_MODE')) {
    return isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)
  }
  return false
}

function getCoordinatorUserContext(mcpClients, scratchpadDir?) {
  let content = `Workers have access to these tools: ${workerTools}`
  
  if (mcpClients.length > 0) {
    content += `\nWorkers also have MCP tools from: ${serverNames}`
  }
  
  if (scratchpadDir && isScratchpadGateEnabled()) {
    content += `\nScratchpad directory: ${scratchpadDir}`
    // Workers 可以在此目录无需权限提示地读写
  }
}

export function isForkSubagentEnabled(): boolean {
  if (feature('FORK_SUBAGENT')) {
    if (isCoordinatorMode()) return false  // 互斥！
    ...
  }
}

// LocalAgentTask.tsx — 原子化防重复通知
function enqueueAgentNotification({ taskId, description, status, ... }) {
  // 原子化 check-and-set：防止重复通知
  let shouldEnqueue = false
  updateTaskState(taskId, setAppState, task => {
    if (task.notified) return task  // 已通知过，跳过
    shouldEnqueue = true
    return { ...task, notified: true }
  })
  if (!shouldEnqueue) return

  // 中止正在进行的推测执行（背景任务状态变更，推测结果可能过时）
  abortSpeculation(setAppState)

  // 构建 XML 通知消息
  const message = `<task-notification>
<task-id>${taskId}</task-id>
<tool-use-id>${toolUseId}</tool-use-id>
<output-file>${outputPath}</output-file>
<status>${status}</status>
<summary>${summary}</summary>
<result>${finalMessage}</result>
<usage><total_tokens>N</total_tokens><tool_uses>N</tool_uses></usage>
<worktree><worktree-path>...</worktree-path></worktree>
</task-notification>`

  enqueuePendingNotification({ value: message, mode: 'task-notification' })
}

function matchSessionMode(sessionMode: 'coordinator' | 'normal' | undefined) {
  if (currentIsCoordinator === sessionIsCoordinator) return undefined

  // 翻转 env var — isCoordinatorMode() 实时读取，无缓存
  if (sessionIsCoordinator) process.env.CLAUDE_CODE_COORDINATOR_MODE = '1'
  else delete process.env.CLAUDE_CODE_COORDINATOR_MODE
}

// 省略 CLAUDE.md（节省 ~5-15 Gtok/周，涉及 3400万+ Explore 调用）
const shouldOmitClaudeMd = agentDefinition.omitClaudeMd && ...

// 省略 gitStatus（节省 ~1-3 Gtok/周）
const resolvedSystemContext =
  agentDefinition.agentType === 'Explore' || agentDefinition.agentType === 'Plan'
    ? systemContextNoGit : baseSystemContext

function shouldInjectAgentListInMessages(): boolean {
  // 将 agent 列表从工具 description 移到 attachment 消息
  // 避免 MCP/plugin/权限变化导致工具 schema 缓存失效
  // 该列表占 fleet cache_creation tokens 的 ~10.2%
}

// Explore/Plan 是一次性 Agent，不需要 SendMessage 继续
const ONE_SHOT_BUILTIN_AGENT_TYPES = new Set(['Explore', 'Plan'])

// 跳过 agentId/SendMessage/usage 尾部
// ~135 字符 × 3400万/周 ≈ 1-2 Gtok/周
if (ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) && !worktreeInfoText) {
  return { content: contentOrMarker }  // 无尾部
}

type AgentMemoryScope = 'user' | 'project' | 'local'

function getAgentMemoryDir(agentType: string, scope: AgentMemoryScope): string {
  switch (scope) {
    case 'user':    return join(getMemoryBaseDir(), 'agent-memory', dirName)
    case 'project': return join(getCwd(), '.claude', 'agent-memory', dirName)
    case 'local':   return join(getCwd(), '.claude', 'agent-memory-local', dirName)
  }
}

async function checkAgentMemorySnapshot(agentType, scope) {
  // 检查是否存在项目快照
  const snapshotMeta = await readJsonFile(getSnapshotJsonPath(agentType), ...)
  
  // 本地无内存 → 从快照初始化
  if (!hasLocalMemory) return { action: 'initialize', snapshotTimestamp }
  
  // 快照比本地新 → 提示更新
  if (new Date(snapshotMeta.updatedAt) > new Date(syncedMeta.syncedFrom))
    return { action: 'prompt-update', snapshotTimestamp }
}

// resumeAgent.ts — 三层过滤确保消息一致性
const resumedMessages = filterWhitespaceOnlyAssistantMessages(    // L3: 空白 assistant
  filterOrphanedThinkingOnlyMessages(                              // L2: 孤立 thinking
    filterUnresolvedToolUses(transcript.messages)                  // L1: 未配对 tool_use
  )
)

// toolResultStorage.ts — 从 sidechain records 重建
function reconstructForSubagentResume(parentState, resumedMessages, sidechainRecords) {
  if (!parentState) return undefined // 功能关闭

  // 从 sidechain records 中提取已知的替换记录
  // parent 的 live replacements 填充 fork 继承的 mustReapply 条目的缺口
  return reconstructContentReplacementState(
    resumedMessages, sidechainRecords, parentState.replacements
  )
}

// 恢复时验证 worktree 目录是否仍然存在
const resumedWorktreePath = meta?.worktreePath
  ? await fsp.stat(meta.worktreePath).then(
      s => s.isDirectory() ? meta.worktreePath : undefined,
      () => { /* 目录不存在，优雅降级到 parent cwd */ return undefined }
    )
  : undefined

// 更新 mtime 防止 stale-worktree 清理删除刚恢复的 worktree (#22355)
if (resumedWorktreePath) {
  await fsp.utimes(resumedWorktreePath, new Date(), new Date())
}

async function initializeAgentMcpServers(agentDefinition, parentClients) {
  for (const spec of agentDefinition.mcpServers) {
    if (typeof spec === 'string') {
      // 字符串引用：查找已有 MCP 配置
      config = getMcpConfigByName(spec)
    } else {
      // 内联定义：{ [name]: config } → 新建连接
      isNewlyCreated = true
    }
    
    const client = await connectToServer(name, config)
    agentClients.push(client)
  }
  
  // 清理：仅清理新创建的连接，不影响共享引用
  const cleanup = async () => {
    for (const client of newlyCreatedClients) {
      await client.cleanup()
    }
  }
  
  return { clients: [...parentClients, ...agentClients], tools: agentTools, cleanup }
}