Function useTaskPoller

apps/kimi-web/src/composables/client/useTaskPoller.ts:22–265

(
  rawState: ExtendedState,
  activeAppTasks: ComputedRef<AppTask[]>,
)

}

export function useTaskPoller(
  rawState: ExtendedState,
  activeAppTasks: ComputedRef<AppTask[]>,
): UseTaskPoller {
  let taskOutputPollTimer: ReturnType<typeof setInterval> | null = null;
  let lastPolledSessionId: string | undefined;
  const fetchedTerminalTaskOutputIds = new Set<string>();

  async function loadTasksForSession(sessionId: string): Promise<void> {
    try {
      const api = getKimiWebApi();
      const taskList = await api.listTasks(sessionId);
      rawState.tasksBySession = {
        ...rawState.tasksBySession,
        // Keep WS-delivered swarm subagents that REST /tasks omits (see keepLiveSubagents).
        [sessionId]: keepLiveSubagents(taskList, rawState.tasksBySession[sessionId] ?? []),
      };
      // Completed tasks may have real terminal output that never streamed over
      // WS. Fetch it once now so the rows are expandable when the session opens.
      await fetchTerminalTaskOutputs(sessionId, taskList);
    } catch {
      // Tasks are side data; old/stale sessions may fail without blocking messages.
    }
  }

  /**
   * Fetch the final output snapshot for terminal tasks that lack real streamed
   * outputLines. Called once after loading the task list so already-completed
   * tasks are clickable immediately.
   */
  async function fetchTerminalTaskOutputs(
    sessionId: string,
    taskList?: AppTask[],
  ): Promise<void> {
    if (rawState.activeSessionId !== sessionId) return;

    const tasks = taskList ?? rawState.tasksBySession[sessionId] ?? [];
    const api = getKimiWebApi();
    const outputByTaskId = new Map<string, { preview: string; bytes?: number }>();

    await Promise.all(
      tasks.map(async (task) => {
        const isTerminal =
          task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled';
        if (!isTerminal) return;
        if (fetchedTerminalTaskOutputIds.has(task.id)) return;
        if ((task.outputLines?.length ?? 0) > 0) return;

        try {
          const withOutput = await api.getTask(sessionId, task.id, {
            withOutput: true,
            outputBytes: TASK_OUTPUT_FINAL_BYTES,
          });
          if (withOutput.outputPreview !== undefined) {
            outputByTaskId.set(task.id, {
              preview: withOutput.outputPreview,
              bytes: withOutput.outputBytes,
            });