Method handleTaskStreamError

src/node/services/taskService.ts:8413–8495

(event: ErrorEvent)

  }

  private async handleTaskStreamError(event: ErrorEvent): Promise<void> {
    if (await this.finalizeWorkspaceTurnFromStreamError(event)) {
      return;
    }
    const workspaceId = event.workspaceId;
    const cfg = this.config.loadConfigOrDefault();
    const entry = findWorkspaceEntry(cfg, workspaceId);
    if (!entry?.workspace.parentWorkspaceId) {
      return;
    }

    const status = entry.workspace.taskStatus;
    // Stream errors only need settlement handling while the task is mid-run
    // (running) or waiting on its completion tool (awaiting_report).
    if (status !== "running" && status !== "awaiting_report") {
      return;
    }
    const taskIndex = this.buildAgentTaskIndex(cfg);

    if (
      await this.interruptTaskRecoveryForInactiveWorkflowOwner(
        workspaceId,
        cfg,
        "stream-error",
        taskIndex
      )
    ) {
      return;
    }

    if (await this.hasActiveTaskOwnedWork(workspaceId, taskIndex)) {
      return;
    }

    const isNonRetryable =
      event.errorType != null && isNonRetryableStreamError({ type: event.errorType });

    // Terminal provider outcomes (e.g. model_refusal) settle the task even during its
    // first `running` turn — previously only awaiting_report settled, leaving the
    // parent's waitForAgentReport to block until timeout. Deliberately an allow-list
    // rather than "all non-retryable":
    // - `aborted` is a steerable user pause, not a terminal failure.
    // - `context_exceeded` has in-session recovery (compaction retry, post-compaction
    //   retry, exec-subagent hard restart in AgentSession.handleStreamError) listening
    //   on the same error event; settling here would race that recovery and interrupt
    //   a child that was about to continue.
    const settlesRunningTask =
      event.errorType != null && RUNNING_TASK_TERMINAL_STREAM_ERRORS.has(event.errorType);

    if (isNonRetryable && (status === "awaiting_report" || settlesRunningTask)) {
      log.error("Task hit a non-retryable stream error; interrupting task", {
        workspaceId,
        taskStatus: status,
        errorType: event.errorType,
        error: event.error,
      });
      await this.failAgentTaskTerminally(workspaceId, entry, {
        errorType: event.errorType ?? "unknown",