CC源码剖析 #13 · Task 执行引擎：从创建到完成的完整流程

1
2
3
4
5
6
7
8

export type TaskState =
  | LocalShellTaskState      // 本地 Shell 任务
  | LocalAgentTaskState     // 本地 Agent 任务
  | RemoteAgentTaskState    // 远程 Agent 任务
  | InProcessTeammateTaskState  // 进程内队友任务
  | LocalWorkflowTaskState  // 本地工作流任务
  | MonitorMcpTaskState     // MCP 监控任务
  | DreamTaskState          // 背景做梦任务

1
2
3
4
5
6
7

type TaskStatus =
  | 'pending'    // 等待执行
  | 'running'    // 执行中
  | 'completed'  // 完成
  | 'failed'     // 失败
  | 'killed'     // 被停止
  | 'paused'     // 暂停

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 判断任务是否显示在后台任务指示器
export function isBackgroundTask(task: TaskState): boolean {
  if (task.status !== 'running' && task.status !== 'pending') {
    return false
  }
  // 前台任务（isBackgrounded === false）不显示
  if ('isBackgrounded' in task && task.isBackgrounded === false) {
    return false
  }
  return true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 创建新任务
const TaskCreateTool = {
  inputSchema: z.object({
    prompt: z.string(),        // 任务描述
    taskType: z.enum([...]).default('agent'),
    agentType?: string,        // Agent 类型
    background?: boolean,      // 是否后台运行
  }),

  async call(args, context, canUseTool) {
    // 1. 验证参数
    // 2. 创建 Task 实例
    // 3. 如果 background=true，设为后台任务
    // 4. 返回 taskId
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

interface LocalAgentTaskState {
  taskId: string
  status: TaskStatus
  agentId: string
  prompt: string
  model?: string
  tools: string[]
  isBackgrounded: boolean
  createdAt: number
  startedAt?: number
  completedAt?: number
  result?: string
  error?: string
}

1
2
3
4
5
6
7

async function runLocalAgentTask(task: LocalAgentTaskState): Promise<void> {
  // 1. 初始化 Agent 上下文
  // 2. 设置系统提示
  // 3. 注入任务 prompt
  // 4. 执行 Tool Call 循环
  // 5. 返回结果或错误
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 进程内队友任务
// 与主会话共享内存
// 通过 mailbox 通信

interface InProcessTeammateTaskState {
  taskId: string
  status: TaskStatus
  teammateId: string
  mailbox: Mailbox
  // 共享消息队列
}

1
2
3
4
5
6
7
8

// 全局任务存储
interface TaskStore {
  tasks: Map<string, TaskState>
  addTask(task: TaskState): void
  updateTask(taskId: string, update: Partial<TaskState>): void
  removeTask(taskId: string): void
  getTask(taskId: string): TaskState | undefined
}

1
2
3
4
5

// 任务状态保存到会话存储
// 恢复时可以重建任务

saveTaskState(taskId: string, state: TaskState): void
loadTaskState(taskId: string): TaskState | undefined

1
2
3
4
5
6
7
8
9

// 状态变更回调
onTaskStatusChange((taskId, oldStatus, newStatus) => {
  // taskId 创建的任务状态变更
})

// 可能的事件序列：
// pending → running → completed
// pending → running → failed
// running → killed

1
2
3
4
5
6
7
8

// 任务完成时的回调
onTaskComplete((taskId, result) => {
  // 处理任务结果
})

onTaskFailure((taskId, error) => {
  // 处理任务失败
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

const TaskStopTool = {
  inputSchema: z.object({
    taskId: z.string(),
    reason: z.string().optional(),
  }),

  async call(args, context, canUseTool) {
    // 1. 查找任务
    // 2. 发送停止信号
    // 3. 等待任务清理
    // 4. 更新状态为 killed
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 任务可以在任意时刻检查停止信号
// 响应 interrupt 信号

class Task {
  private abortController: AbortController

  async stop(): Promise<void> {
    this.abortController.abort()
  }

  isStopped(): boolean {
    return this.abortController.signal.aborted
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 任务结果通过 task-notification 传递
interface TaskNotification {
  type: 'task-notification'
  taskId: string
  status: 'completed' | 'failed' | 'killed'
  summary: string
  result?: string
  usage?: {
    total_tokens: number
    tool_uses: number
    duration_ms: number
  }
}

1
2
3
4

// 任务结果注入到主会话消息流
// 作为 user-role message 到达（区分于人类消息）

injectTaskNotification(taskId: string, result: TaskNotification): void

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 显示所有后台任务
// 状态、进度、结果

const TaskListV2: React.FC = () => {
  const tasks = useTasksV2WithCollapseEffect()

  return (
    <Box>
      {tasks.map(task => (
        <TaskItem key={task.taskId} task={task} />
      ))}
    </Box>
  )
}