第 09 章：AI说要执行命令

type ContentBlock = TextBlock | ToolUseBlock

// → src/query.ts 的 tool_use 识别逻辑
const msgToolUseBlocks = message.message.content.filter(
  content => content.type === 'tool_use',
) as ToolUseBlock[]

if (msgToolUseBlocks.length > 0) {
  toolUseBlocks.push(...msgToolUseBlocks)
  needsFollowUp = true
}

// → src/Tool.ts 的 findToolByName() 函数
export function findToolByName(tools: Tools, name: string): Tool | undefined {
  return tools.find(t => toolMatchesName(t, name))
}

// → src/Tool.ts 的 toolMatchesName() 函数
export function toolMatchesName(
  tool: { name: string; aliases?: string[] },
  name: string,
): boolean {
  return tool.name === name || (tool.aliases?.includes(name) ?? false)
}

// → src/Tool.ts 的 Tool 类型（简化版）
export type Tool<
  Input extends AnyObject = AnyObject,
  Output = unknown,
  P extends ToolProgressData = ToolProgressData,
> = {
  readonly name: string           // 工具名字
  readonly inputSchema: Input     // 输入规则（Zod schema）
  call(                           // 执行函数
    args: z.infer<Input>,
    context: ToolUseContext,
    canUseTool: CanUseToolFn,
    parentMessage: AssistantMessage,
    onProgress?: ToolCallProgress<P>,
  ): Promise<ToolResult<Output>>
  // ... 还有 isEnabled、isReadOnly、isDestructive、checkPermissions 等
}

// → src/services/tools/toolExecution.ts 的 runToolUse() 函数
export async function* runToolUse(
  toolUse: ToolUseBlock,
  assistantMessage: AssistantMessage,
  canUseTool: CanUseToolFn,
  toolUseContext: ToolUseContext,
): AsyncGenerator<MessageUpdateLazy, void> {
  const toolName = toolUse.name
  let tool = findToolByName(toolUseContext.options.tools, toolName)

  if (!tool) {
    // 工具不存在！
    yield {
      message: createUserMessage({
        content: [{
          type: 'tool_result',
          content: `<tool_use_error>Error: No such tool available: ${toolName}</tool_use_error>`,
          is_error: true,
          tool_use_id: toolUse.id,
        }],
      }),
    }
    return
  }
  // ... 继续执行工具 ...
}

// → src/services/tools/StreamingToolExecutor.ts 的 addTool() 方法
addTool(block: ToolUseBlock, assistantMessage: AssistantMessage): void {
  const toolDefinition = findToolByName(this.toolDefinitions, block.name)

  if (!toolDefinition) {
    // 工具不存在 → 立即返回错误
    this.tools.push({
      status: 'completed',
      results: [createUserMessage({ ... })]
    })
    return
  }

  // 解析输入，判断是否并发安全
  const parsedInput = toolDefinition.inputSchema.safeParse(block.input)
  const isConcurrencySafe = parsedInput?.success
    ? Boolean(toolDefinition.isConcurrencySafe(parsedInput.data))
    : false

  this.tools.push({ block, status: 'queued', isConcurrencySafe })

  // 立即尝试执行
  void this.processQueue()
}

// → src/services/tools/StreamingToolExecutor.ts 的 canExecuteTool() 方法
private canExecuteTool(isConcurrencySafe: boolean): boolean {
  const executingTools = this.tools.filter(t => t.status === 'executing')
  return (
    executingTools.length === 0 ||  // 没有在执行的 → 可以开始
    (isConcurrencySafe && executingTools.every(t => t.isConcurrencySafe))
    // 当前工具安全 + 所有执行中的也安全 → 可以并行
  )
}

if (msgToolUseBlocks.length > 0) {
  console.log('[DEBUG] tool_use blocks found:', msgToolUseBlocks.map(b => b.name))
}

console.log('[DEBUG] Looking for tool:', name, 'found:', !!found)

const executing = this.tools.filter(t => t.status === 'executing')
console.log('[DEBUG] canExecute:', isConcurrencySafe, 'executing:', executing.map(t => t.block.name))