工具执行引擎

// toolExecution.ts — 简化版
export async function runToolUse(
  toolCall: ToolUseBlock,
  tools: Tool[],
  context: ToolUseContext,
  hooks: ToolHooks
): Promise<ToolResultBlockParam> {
  // 1. 查找工具
  const tool = tools.find(t =>
    t.name === toolCall.name ||
    t.aliases?.includes(toolCall.name)
  )
  if (!tool) {
    return {
      type: 'tool_result',
      tool_use_id: toolCall.id,
      content: 'Unknown tool: ' + toolCall.name,
      is_error: true,
    }
  }

  // 2. PreToolUse 钩子
  const preHookResult = await hooks.runPreToolUseHooks({
    tool,
    input: toolCall.input,
    context,
  })
  if (preHookResult?.intercepted) {
    // 钩子提供了替代结果，跳过实际执行
    return preHookResult.result
  }
  // 钩子可能修改了输入
  const input = preHookResult?.modifiedInput ?? toolCall.input

  // 3. 权限检查
  const permResult = await tool.checkPermissions(
    input,
    context.options.permissionContext
  )
  if (permResult.denied) {
    // 需要用户确认或直接拒绝
    return await handlePermissionDenial(permResult, tool, context)
  }

  // 4. 输入校验
  const parseResult = tool.inputSchema.safeParse(input)
  if (!parseResult.success) {
    return buildErrorResult(toolCall.id, parseResult.error)
  }
  if (tool.validateInput) {
    const validationError = await tool.validateInput(parseResult.data)
    if (validationError) {
      return buildErrorResult(toolCall.id, validationError)
    }
  }

  // 5. 执行工具
  let toolResult: ToolResult
  try {
    toolResult = await tool.call(parseResult.data, context)
  } catch (error) {
    // 错误分类
    const classified = classifyError(error)
    trackTelemetry('tool_error', {
      tool: tool.name,
      errorName: classified.stableName,
    })
    return buildErrorResult(toolCall.id, classified.message)
  }

  // 6. PostToolUse 钩子
  toolResult = await hooks.runPostToolUseHooks({
    tool,
    input,
    result: toolResult,
    context,
  })

  // 7. 结果预算控制
  const resultParam = await buildToolResultParam(
    toolCall.id, tool, toolResult
  )

  // 8. 文件历史追踪
  if (!tool.isReadOnly()) {
    trackFileHistory(tool.name, input, context)
  }

  return resultParam
}

// toolOrchestration.ts — 简化版

interface PartitionedCalls {
  parallelBatch: ToolUseBlock[]
  serialBatch: ToolUseBlock[]
}

export function partitionToolCalls(
  toolCalls: ToolUseBlock[],
  tools: Tool[]
): PartitionedCalls {
  const parallelBatch: ToolUseBlock[] = []
  const serialBatch: ToolUseBlock[] = []

  for (const call of toolCalls) {
    const tool = tools.find(t => t.name === call.name)
    if (tool?.isConcurrencySafe()) {
      parallelBatch.push(call)
    } else {
      serialBatch.push(call)
    }
  }

  return { parallelBatch, serialBatch }
}

// 执行编排
export async function executeToolCalls(
  toolCalls: ToolUseBlock[],
  tools: Tool[],
  context: ToolUseContext
): Promise<ToolResultBlockParam[]> {
  const { parallelBatch, serialBatch } = partitionToolCalls(
    toolCalls, tools
  )

  // 阶段 1：并发执行（所有并发安全的工具同时启动）
  const parallelResults = await Promise.all(
    parallelBatch.map(call => runToolUse(call, tools, context))
  )

  // 阶段 2：串行执行（有副作用的工具逐个执行）
  const serialResults: ToolResultBlockParam[] = []

  // 为同批次 Bash 调用创建兄弟 AbortController
  const siblingAbort = new AbortController()
  const bashCalls = serialBatch.filter(c => c.name === 'Bash')

  for (const call of serialBatch) {
    // 如果兄弟 Bash 已失败，跳过剩余 Bash 调用
    if (call.name === 'Bash' && siblingAbort.signal.aborted) {
      serialResults.push({
        type: 'tool_result',
        tool_use_id: call.id,
        content: 'Skipped: sibling Bash command failed',
        is_error: true,
      })
      continue
    }

    try {
      const result = await runToolUse(call, tools, {
        ...context,
        abortController: call.name === 'Bash'
          ? siblingAbort
          : context.abortController,
      })
      serialResults.push(result)
    } catch (error) {
      // Bash 错误触发兄弟 abort
      if (call.name === 'Bash' && bashCalls.length > 1) {
        siblingAbort.abort()
      }
      serialResults.push(buildErrorResult(call.id, error))
    }
  }

  // 按原始顺序合并结果
  return mergeResultsInOrder(
    toolCalls, parallelResults, serialResults
  )
}

// toolResultStorage.ts — 大结果持久化
import { writeFile, mkdtemp } from 'fs/promises'
import { join } from 'path'
import { tmpdir } from 'os'

const DEFAULT_MAX_CHARS = 30_000

export async function buildToolResultParam(
  toolUseId: string,
  tool: Tool,
  result: ToolResult
): Promise<ToolResultBlockParam> {
  const maxChars = tool.maxResultSizeChars ?? DEFAULT_MAX_CHARS
  const content = typeof result.data === 'string'
    ? result.data
    : JSON.stringify(result.data)

  // 结果在预算内：直接返回
  if (content.length <= maxChars) {
    return {
      type: 'tool_result',
      tool_use_id: toolUseId,
      content,
    }
  }

  // 结果超预算：持久化到磁盘
  const tmpDir = await mkdtemp(join(tmpdir(), 'cc-result-'))
  const filePath = join(tmpDir, 'result.txt')
  await writeFile(filePath, content, 'utf-8')

  // 生成预览（前 100 行 + 截断提示）
  const lines = content.split('\n')
  const previewLines = lines.slice(0, 100)
  const preview = [
    ...previewLines,
    '',
    '... (结果共 ' + lines.length + ' 行，' + content.length + ' 字符)',
    '完整结果已保存到: ' + filePath,
    '使用 Read 工具配合 offset 参数查看完整内容',
  ].join('\n')

  return {
    type: 'tool_result',
    tool_use_id: toolUseId,
    content: preview,
  }
}

// 错误分类系统
export interface ClassifiedError {
  stableName: string      // 用于遥测聚合
  message: string         // 用户友好的消息
  isTelemetrySafe: boolean // 是否可安全发送
}

export function classifyError(error: unknown): ClassifiedError {
  // TelemetrySafeError：开发者标记的安全错误
  if (error instanceof TelemetrySafeError) {
    return {
      stableName: error.name,
      message: error.message,
      isTelemetrySafe: true,
    }
  }

  // 系统 errno 错误
  if (isErrnoError(error)) {
    const mapped = ERRNO_MAP[error.code] ?? {
      name: 'unknown_system_error',
      message: '系统错误: ' + error.code,
    }
    return { ...mapped, isTelemetrySafe: true }
  }

  // 未知错误：不发送详细信息到遥测
  return {
    stableName: 'unknown_error',
    message: error instanceof Error
      ? error.message
      : 'An unknown error occurred',
    isTelemetrySafe: false,
  }
}

const ERRNO_MAP: Record<string, { name: string; message: string }> = {
  ENOENT:  { name: 'file_not_found',   message: '文件或目录不存在' },
  EACCES:  { name: 'permission_denied', message: '没有访问权限' },
  EISDIR:  { name: 'is_directory',      message: '目标是目录，不是文件' },
  ENOSPC:  { name: 'no_space',          message: '磁盘空间不足' },
  EMFILE:  { name: 'too_many_files',    message: '打开的文件数过多' },
}