import * as path from "path"

import * as vscode from "vscode"

import os from "os"

import crypto from "crypto"

import { v7 as uuidv7 } from "uuid"

import EventEmitter from "events"

import { AskIgnoredError } from "./AskIgnoredError"

import { RateLimitClock, createRateLimitClock } from "./RateLimitClock"

import { Anthropic } from "@anthropic-ai/sdk"

import OpenAI from "openai"

import debounce from "lodash.debounce"

import delay from "delay"

import pWaitFor from "p-wait-for"

import { serializeError } from "serialize-error"

import { Package } from "../../shared/package"

import {

type TaskLike,

type TaskMetadata,

type TaskEvents,

type ProviderSettings,

type TokenUsage,

type ToolUsage,

type ToolName,

type ContextCondense,

type ContextTruncation,

type ClineMessage,

type ClineSay,

type ClineAsk,

type ExtensionState,

type ToolProgressStatus,

type HistoryItem,

type PendingTaskAction,

type CreateTaskOptions,

type ModelInfo,

type ClineApiReqCancelReason,

type ClineApiReqInfo,

RooCodeEventName,

TelemetryEventName,

TaskStatus,

TodoItem,

getApiProtocol,

getModelId,

isRetiredProvider,

isIdleAsk,

isInteractiveAsk,

isResumableAsk,

QueuedMessage,

DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,

DEFAULT_TOOL_REPETITION_SOFT_LIMIT,

normalizeToolRepetitionSoftLimit,

DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,

MAX_CHECKPOINT_TIMEOUT_SECONDS,

MIN_CHECKPOINT_TIMEOUT_SECONDS,

MAX_MCP_TOOLS_THRESHOLD,

countEnabledMcpTools,

providerIdentifiers,

} from "@roo-code/types"

import { TelemetryService } from "@roo-code/telemetry"

import { CloudService } from "@roo-code/cloud"

// api

import { ApiHandler, ApiHandlerCreateMessageMetadata, buildApiHandler } from "../../api"

import { disposeApiHandler } from "../../api/dispose-api-handler"

import { ApiStream, GroundingSource } from "../../api/transform/stream"

import { maybeRemoveImageBlocks } from "../../api/transform/image-cleaning"

import { OutputTokenLimitError } from "../../api/providers/utils/output-token-limit-error"

// shared

import { findLast, findLastIndex } from "../../shared/array"

import { combineApiRequests } from "../../shared/combineApiRequests"

import { combineCommandSequences } from "../../shared/combineCommandSequences"

import { t } from "../../i18n"

import { getApiMetrics, hasTokenUsageChanged, hasToolUsageChanged } from "../../shared/getApiMetrics"

import { ClineAskResponse } from "../../shared/WebviewMessage"

import { defaultModeSlug, getModeBySlug } from "../../shared/modes"

import { DiffStrategy, type AutoApprovalContext, type ToolUse } from "../../shared/tools"

import { getModelMaxOutputTokens } from "../../shared/api"

// services

import { McpHub } from "../../services/mcp/McpHub"

import { McpServerManager } from "../../services/mcp/McpServerManager"

import { RepoPerTaskCheckpointService } from "../../services/checkpoints"

// integrations

import { DiffViewProvider } from "../../integrations/editor/DiffViewProvider"

import { RooTerminalProcess } from "../../integrations/terminal/types"

import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry"

import { OutputInterceptor } from "../../integrations/terminal/OutputInterceptor"

// utils

import { calculateApiCostAnthropic, calculateApiCostOpenAI } from "../../shared/cost"

import { getWorkspacePath } from "../../utils/path"

import { sanitizeToolUseId } from "../../utils/tool-id"

import { getTaskDirectoryPath } from "../../utils/storage"

// prompts

import { formatResponse } from "../prompts/responses"

import { SYSTEM_PROMPT } from "../prompts/system"

import { partitionDisabledToolsForProtocol } from "../prompts/tools/effective-tool-policy"

import { buildNativeToolsArrayWithRestrictions } from "./build-tools"

// core modules

import { ToolRepetitionDetector } from "../tools/ToolRepetitionDetector"

import { restoreTodoListForTask } from "../tools/UpdateTodoListTool"

import { FileContextTracker } from "../context-tracking/FileContextTracker"

import { ObservationRegistry } from "./observationRegistry"

import { RooIgnoreController } from "../ignore/RooIgnoreController"

import { RooProtectedController } from "../protect/RooProtectedController"

import { type AssistantMessageContent, presentAssistantMessage } from "../assistant-message"

import { DispatchState, type PendingWork } from "./dispatchState"

import { type RequestPolicySnapshot } from "../prompts/tools/effective-tool-policy"

import { NativeToolCallParser } from "../assistant-message/NativeToolCallParser"

import { type ContextManagementResult, manageContext, willManageContext } from "../context-management"

import { ClineProvider } from "../webview/ClineProvider"

import { MultiSearchReplaceDiffStrategy } from "../diff/strategies/multi-search-replace"

import {

type ApiMessage,

ensureMessageIdentifiers,

readApiMessages,

saveApiMessages,

readTaskMessages,

saveTaskMessages,

taskMetadata,

} from "../task-persistence"

import { getEnvironmentDetails } from "../environment/getEnvironmentDetails"

import { checkContextWindowExceededError } from "../context/context-management/context-error-handling"

import {

type CheckpointDiffOptions,

type CheckpointRestoreOptions,

getCheckpointService,

checkpointSave,

checkpointRestore,

checkpointDiff,

} from "../checkpoints"

import { processUserContentMentions } from "../mentions/processUserContentMentions"

import { getMessagesSinceLastSummary, summarizeConversation, getEffectiveApiHistory } from "../condense"

import { MessageQueueService } from "../message-queue/MessageQueueService"

import { type AutoDenyDetail, AutoApprovalHandler, checkAutoApproval } from "../auto-approval"

import { MessageManager } from "../message-manager"

import { validateAndFixToolResultIds } from "./validateToolResultIds"

import { mergeConsecutiveApiMessages } from "./mergeConsecutiveApiMessages"

import { prepareApiConversationMessage } from "./apiConversationHistory"

import { shouldAddUserMessageToHistory } from "./messageCounting"

import { type TaskExecutionContext } from "./providerHandoff"

import { abort, abortReason, initialRunState, type Ask, type RunEvent, type RunState } from "./run-state/runState"

import { applyRunEvent, type RunRejection } from "./run-state/runStateShadow"

import {

divergenceKey,

findDivergences,

isDivergenceCheckEnabled,

reportDivergence,

} from "./run-state/runStateDivergence"

const MAX_EXPONENTIAL_BACKOFF_SECONDS = 600 // 10 minutes

const DEFAULT_USAGE_COLLECTION_TIMEOUT_MS = 5000 // 5 seconds

// Streamed deltas arrive far faster than the webview can usefully re-render a growing message

// (tables and code fences reflow on nearly every update), so partial updates post at most this often.

const PARTIAL_MESSAGE_UPDATE_INTERVAL_MS = 120

// Upper bound on awaiting lazily loaded model metadata. Some model-catalog

// fetchers (e.g. OpenRouter's bare axios GET) have no request timeout, so a

// hung endpoint must not stall streaming, condense, or context-window

// handling. On expiry the caller aborts its per-call AbortSignal (detaching

// the provider-side waiter) and falls back to the handler's existing

// getModel().info metadata — the same degradation a rejected fetch produces.

// Kept in sync with PREVIEW_MODEL_FETCH_TIMEOUT_MS in the preview path

// (src/core/webview/generateSystemPrompt.ts). Deliberately duplicated, not

// shared: importing from the webview layer would close a

// Task -> generateSystemPrompt -> ClineProvider -> Task circular import.

export const MODEL_FETCH_TIMEOUT_MS = 5_000

const QUEUED_FEEDBACK_SAVE_RETRY_DELAYS_MS = [250, 1_000, 4_000] as const

type QueuedAskResolution = { response: ClineAskResponse; requiresDurableAck: boolean }

/**

* Denial kinds the command policy produces only while blanket auto-deny is on

* (`checkAutoApproval` returns `ask` for these when the setting is off — see

* the command branch of `src/core/auto-approval/index.ts`), so a denial of one

* of these kinds is blanket-caused. `denylist` and `guard_unavailable` are

* excluded: they deny independently of the blanket setting.

*/

export const BLANKET_DENY_AUTO_DENY_KINDS: ReadonlySet<AutoDenyDetail["kind"]> = new Set([

"dcg",

"not_allowlisted",

"dangerous_substitution",

"malformed_command",

])

/**

* What to do with a claimed queued message about to answer a command ask,

* decided against the auto-approval policy as it stands NOW.

*/

type QueuedCommandPolicyAction =

{ action: "consume" } | { action: "approve" } | { action: "deny"; detail?: AutoDenyDetail } | { action: "release" }

/**

* Whether blanket auto-deny currently engages. The three settings act as a

* conjunction: blanket deny only means anything while auto-approval is on and

* command auto-approval is on — without those two an unapproved command is

* prompted rather than auto-approved, so there is nothing to deny.

*

* Single source of truth for the derivation: the ask-time snapshot, the

* consume-site re-reads, and the tool-level execute-time re-check must not

* drift apart, or a flip landing between two of them decides execution or

* consumption on stale policy.

*/

export function isBlanketDenyEngaged(

state?: Pick<ExtensionState, "alwaysDenyUnapprovedCommands" | "autoApprovalEnabled" | "alwaysAllowExecute">,

): boolean {

return (

state?.alwaysDenyUnapprovedCommands === true &&

state?.autoApprovalEnabled === true &&

state?.alwaysAllowExecute === true

)

}

function queuedResponseForAsk(type: ClineAsk, text?: string): QueuedAskResolution | undefined {

if (type === "command_output") {

return undefined

}

if (type === "tool") {

try {

const tool = JSON.parse(text || "{}") as { tool?: string }

if (tool.tool === "newTask" || tool.tool === "finishTask") {

return { response: "messageResponse", requiresDurableAck: true }

}

} catch {

// Malformed tool asks retain the existing approve-with-feedback behavior.

}

return { response: "yesButtonClicked", requiresDurableAck: false }

}

if (type === "command" || type === "use_mcp_server") {

return { response: "yesButtonClicked", requiresDurableAck: false }

}

return { response: "messageResponse", requiresDurableAck: type === "completion_result" }

}

const FORCED_CONTEXT_REDUCTION_PERCENT = 75 // Keep 75% of context (remove 25%) on context window errors

const MAX_CONTEXT_WINDOW_RETRIES = 3 // Maximum retries for context window errors

export interface ToolExecutionContext {

toolCallId: string

didReject: boolean

}

export interface TaskOptions extends CreateTaskOptions {

provider: ClineProvider

apiConfiguration: ProviderSettings

enableCheckpoints?: boolean

checkpointTimeout?: number

consecutiveMistakeLimit?: number

task?: string

images?: string[]

historyItem?: HistoryItem

experiments?: Record<string, boolean>

startTask?: boolean

rootTask?: Task

parentTask?: Task

taskNumber?: number

onCreated?: (task: Task) => void

initialTodos?: TodoItem[]

workspacePath?: string

/** Initial status for the task's history item (e.g., "active" for child tasks) */

initialStatus?: "active" | "delegated" | "completed" | "interrupted"

rateLimitClock?: RateLimitClock

diffFuzzyThreshold?: number

/** Explicit task-local execution context for a delegated child. */

handoffExecutionContext?: TaskExecutionContext

}

type AssistantMessagePersistenceResult = boolean

type AssistantMessagePersistenceCancellation = {

cancelled: boolean

promise: Promise<void>

resolve: () => void

}

export class PendingActionSettlementError extends Error {

constructor(message: string, options?: ErrorOptions) {

super(message, options)

this.name = "PendingActionSettlementError"

}

}

export class Task extends EventEmitter<TaskEvents> implements TaskLike {

readonly taskId: string

readonly rootTaskId?: string

readonly parentTaskId?: string

childTaskId?: string

pendingNewTaskToolCallId?: string

readonly instanceId: string

readonly metadata: TaskMetadata

// The observed on-disk version of each file this task has read. Declared here so the

// read tools can record it; a write guard later compares a token against this registry.

readonly observationRegistry = new ObservationRegistry()

todoList?: TodoItem[]

readonly rootTask: Task | undefined = undefined

readonly parentTask: Task | undefined = undefined

readonly taskNumber: number

readonly workspacePath: string

/**

* The mode associated with this task. Persisted across sessions

* to maintain user context when reopening tasks from history.

*

* ## Lifecycle

*

* ### For new tasks:

* 1. Initially `undefined` during construction

* 2. Asynchronously initialized from provider state via `initializeTaskMode()`

* 3. Falls back to `defaultModeSlug` if provider state is unavailable

*

* ### For history items:

* 1. Immediately set from `historyItem.mode` during construction

* 2. Falls back to `defaultModeSlug` if mode is not stored in history

*

* ## Important

* This property should NOT be accessed directly until `taskModeReady` promise resolves.

* Use `getTaskMode()` for async access or `taskMode` getter for sync access after initialization.

*

* @private

* @see {@link getTaskMode} - For safe async access

* @see {@link taskMode} - For sync access after initialization

* @see {@link waitForModeInitialization} - To ensure initialization is complete

*/

private _taskMode: string | undefined

/**

* Promise that resolves when the task mode has been initialized.

* This ensures async mode initialization completes before the task is used.

*

* ## Purpose

* - Prevents race conditions when accessing task mode

* - Ensures provider state is properly loaded before mode-dependent operations

* - Provides a synchronization point for async initialization

*

* ## Resolution timing

* - For history items: Resolves immediately (sync initialization)

* - For new tasks: Resolves after provider state is fetched (async initialization)

*

* @private

* @see {@link waitForModeInitialization} - Public method to await this promise

*/

private taskModeReady: Promise<void>

/**

* The API configuration name (provider profile) associated with this task.

* Persisted across sessions to maintain the provider profile when reopening tasks from history.

*

* ## Lifecycle

*

* ### For new tasks:

* 1. Initially `undefined` during construction

* 2. Asynchronously initialized from provider state via `initializeTaskApiConfigName()`

* 3. Falls back to "default" if provider state is unavailable

*

* ### For history items:

* 1. Immediately set from `historyItem.apiConfigName` during construction

* 2. Falls back to undefined if not stored in history (for backward compatibility)

*

* ## Important

* If you need a non-`undefined` provider profile (e.g., for profile-dependent operations),

* wait for `taskApiConfigReady` first (or use `getTaskApiConfigName()`).

* The sync `taskApiConfigName` getter may return `undefined` for backward compatibility.

*

* @private

* @see {@link getTaskApiConfigName} - For safe async access

* @see {@link taskApiConfigName} - For sync access after initialization

*/

private _taskApiConfigName: string | undefined

/**

* Promise that resolves when the task API config name has been initialized.

* This ensures async API config name initialization completes before the task is used.

*

* ## Purpose

* - Prevents race conditions when accessing task API config name

* - Ensures provider state is properly loaded before profile-dependent operations

* - Provides a synchronization point for async initialization

*

* ## Resolution timing

* - For history items: Resolves immediately (sync initialization)

* - For new tasks: Resolves after provider state is fetched (async initialization)

*

* @private

*/

private taskApiConfigReady: Promise<void>

providerRef: WeakRef<ClineProvider>

private readonly globalStoragePath: string

// Monotonic cancellation counter. `requestAbort()` and `requestDispose()` advance

// this fence, and the guarded-write path compares the value it captured when the

// write was queued with the value at publish time, so a queued write cannot publish

// after the task was cancelled or disposed.

cancellationGeneration: number = 0

currentRequestAbortController?: AbortController

/**

* Controller for the waiter on an in-flight `ensureModelFetched()` call (see

* safeEnsureModelFetched). Aborting it detaches this task from the provider-side

* metadata fetch; it is aborted when the bounded wait expires and when the task's

* current request is cancelled (cancel/dispose path in cancelCurrentRequest).

*/

metadataFetchAbortController?: AbortController

skipPrevResponseIdOnce: boolean = false

// TaskStatus

idleAsk?: ClineMessage

resumableAsk?: ClineMessage

interactiveAsk?: ClineMessage

didFinishAbortingStream = false

abandoned = false

isInitialized = false

runState: RunState = initialRunState

readonly runRejections: RunRejection[] = []

private readonly divergenceCheckEnabled: boolean

private readonly reportedDivergences = new Set<string>()

// API

apiConfiguration: ProviderSettings

api: ApiHandler

/**

* Units of in-flight API work: a request from setup through its retries and

* background usage drain, or a manual condense. Work can hold any handler it

* read from `this.api`, so replaced handlers wait for the count to reach zero.

*/

private activeApiWork = 0

/** Handlers replaced during in-flight work; disposed when that work settles, or with the task. */

private retiredApis = new Set<ApiHandler>()

private rateLimitClock: RateLimitClock

private autoApprovalHandler: AutoApprovalHandler

toolRepetitionDetector: ToolRepetitionDetector

rooIgnoreController?: RooIgnoreController

rooProtectedController?: RooProtectedController

fileContextTracker: FileContextTracker

terminalProcesses = new Map<string, RooTerminalProcess>()

activeToolContexts = new Map<string, ToolExecutionContext>()

// Editing

diffViewProvider: DiffViewProvider

diffStrategy?: DiffStrategy

didEditFile: boolean = false

// LLM Messages & Chat Messages

apiConversationHistory: ApiMessage[] = []

clineMessages: ClineMessage[] = []

// Ask

private askResponse?: ClineAskResponse

private askResponseText?: string

private askResponseImages?: string[]

/**

* Structured detail of the automatic denial that resolved the current ask,

* set when `checkAutoApproval` denies via policy (denylist, blanket

* auto-deny, or a DCG block in blanket mode) and consumed (cleared) by the

* `ask()` result. System-generated, unlike `askResponseText` which carries

* user feedback and triggers a `user_feedback` say row.

*/

private pendingAutoDenyDetail?: AutoDenyDetail

/**

* Set while the current turn has blanket-denied a command ask. The queued

* messages such a denial deliberately leaves in place were typed in response

* to that denial, not as approval — so a later ask in the same turn must not

* consume one as `yesButtonClicked` (which would silently approve it with the

* interactive prompt suppressed). Read at the queued-message consume sites;

* cleared by the per-turn reset beside `didToolFailInCurrentTurn`.

*/

private blanketDeniedCommandThisTurn = false

public lastMessageTs?: number

private autoApprovalTimeoutRef?: NodeJS.Timeout

// Tool Use

consecutiveMistakeCount: number = 0

consecutiveMistakeLimit: number

toolRepetitionSoftLimit: number

consecutiveMistakeCountForApplyDiff: Map<string, number> = new Map()

consecutiveMistakeCountForEditFile: Map<string, number> = new Map()

consecutiveNoToolUseCount: number = 0

consecutiveNoAssistantMessagesCount: number = 0

toolUsage: ToolUsage = {}

// Conversation message counts, summarized once per Task Completed

// installment instead of emitting a separate telemetry event per turn.

messageCounts: { user: number; assistant: number } = { user: 0, assistant: 0 }

// Idle/shutdown telemetry flush: reports toolUsage/messageCounts for tasks that

// go quiet or get torn down without the model ever calling attempt_completion

// (or without the user accepting it), so long-running/abandoned tasks aren't

// invisible to telemetry. Each flush reports only what changed since the previous

// one, tracked via telemetryToolUsageBaseline/telemetryMessageCountsBaseline --

// task.toolUsage/messageCounts themselves are never mutated by this, since they're

// also read as running totals by the public TaskCompleted API event and the UI.

// Checked on an interval rather than hooked into every say()/ask() call site.

private static readonly IDLE_TELEMETRY_CHECK_INTERVAL_MS = 5 * 60 * 1000

private static readonly IDLE_TELEMETRY_THRESHOLD_MS = 30 * 60 * 1000

private idleTelemetryCheckInterval?: NodeJS.Timeout

private lastTelemetryFlushAt: number = Date.now()

private telemetryToolUsageBaseline: ToolUsage = {}

private telemetryMessageCountsBaseline: { user: number; assistant: number } = { user: 0, assistant: 0 }

private abortPromise?: Promise<void>

private disposalPromise?: Promise<void>

private diffReversionPromise: Promise<void> = Promise.resolve()

// Checkpoints

enableCheckpoints: boolean

checkpointTimeout: number

checkpointService?: RepoPerTaskCheckpointService

checkpointServiceInitializing = false

// Message Queue Service

public readonly messageQueueService: MessageQueueService

private messageQueueStateChangedHandler: (() => void) | undefined

// Streaming

isWaitingForFirstChunk = false

isStreaming = false

currentStreamingContentIndex = 0

currentStreamingDidCheckpoint = false

assistantMessageContent: AssistantMessageContent[] = []

dispatchState: DispatchState = DispatchState.IDLE

pendingWork: PendingWork | null = null

userMessageContent: (Anthropic.TextBlockParam | Anthropic.ImageBlockParam | Anthropic.ToolResultBlockParam)[] = []

userMessageContentReady = false

/**

* Flag indicating whether the assistant message for the current streaming session

* has been saved to API conversation history.

*

* This is critical for parallel tool calling: tools should NOT execute until

* the assistant message is saved. Otherwise, if a tool like `new_task` triggers

* `flushPendingToolResultsToHistory()`, the user message with tool_results would

* appear BEFORE the assistant message with tool_uses, causing API errors.

*

* Reset to `false` at the start of each API request.

* Set to `true` only after the assistant message is durably saved.

*/

assistantMessageSavedToHistory = false

private assistantMessagePersistencePromise!: Promise<AssistantMessagePersistenceResult>

private resolveAssistantMessagePersistence!: (result: AssistantMessagePersistenceResult) => void

private assistantMessagePersistenceCancellation?: AssistantMessagePersistenceCancellation

private completionPersistenceReadyPromise?: Promise<void>

/**

* The tool-policy inputs captured for the API request currently being built

* (see `attemptApiRequest`). The streaming presenter reads this field at call

* time and binds it to `presentAssistantMessage`'s required parameter, so

* every tool call of a request validates against the same frozen policy its

* prompt was generated from. Re-assigned per API attempt — including retries,

* whose generator-body re-execution re-captures before any new presentation

* can fire.

*/

private requestPolicySnapshot?: RequestPolicySnapshot

/**

* Fire-and-forget wrapper around `presentAssistantMessage` that swallows the

* expected cancellation rejection (the presenter throws when `this.abort` is set)

* and logs any other failure. Keeping it non-blocking preserves the streaming

* presenter's self-locking semantics while preventing unhandled promise rejections

* from crashing the extension host.

*/

private presentAssistantMessageSafe(): void {

void presentAssistantMessage(this, this.requestPolicySnapshot!).catch((error) => {

// Discriminate on the error message rather than `this.abort` state,

// which can flip between the throw and the catch microtask running:

// a real failure followed by an abort flip would otherwise be

// silently swallowed, and a stale abort error logged as a failure.

// The abort throw site in presentAssistantMessage emits a message

// ending in "aborted" (matching the other abort-throw contracts in

// this file), so we suppress exactly that.

if (error instanceof Error && error.message.endsWith("aborted")) {

return

}

console.error(`[Task#presentAssistantMessage] task ${this.taskId}.${this.instanceId} failed:`, error)

})

}

/**

* Push a tool_result block to userMessageContent, preventing duplicates.

* Duplicate tool_use_ids cause API errors.

*

* Keeps all tool_result blocks first and contiguous, as the Anthropic API

* requires: a user message responding to tool_use blocks must begin with

* the tool_result blocks, and any other content (images, text) between or

* ahead of them is rejected ("tool_use ids were found without tool_result

* blocks immediately after"). All tool_result blocks are therefore kept

* ahead of other content in this array.

*

* @param toolResult - The tool_result block to add

* @returns true if added, false if duplicate was skipped

*/

public pushToolResultToUserContent(toolResult: Anthropic.ToolResultBlockParam): boolean {

const existingResult = this.userMessageContent.find(

(block): block is Anthropic.ToolResultBlockParam =>

block.type === "tool_result" && block.tool_use_id === toolResult.tool_use_id,

)

if (existingResult) {

console.warn(

`[Task#pushToolResultToUserContent] Skipping duplicate tool_result for tool_use_id: ${toolResult.tool_use_id}`,

)

return false

}

this.userMessageContent.push(toolResult)

// Partition into [tool_results, other blocks], preserving order within

// each group, so results stay first and contiguous regardless of what

// other content (images, text) arrived between pushes.

const results = this.userMessageContent.filter(

(block): block is Anthropic.ToolResultBlockParam => block.type === "tool_result",

)

const others = this.userMessageContent.filter((block) => block.type !== "tool_result")

this.userMessageContent.splice(0, this.userMessageContent.length, ...results, ...others)

return true

}

/**

* Derives terminal tool-turn readiness from the protocol state instead of

* relying exclusively on the presenter's one-shot boolean latch.

*

* A re-entrant presenter can lose the latch update after every tool has

* already completed. At that point the assistant turn is safe to continue

* when the stream is closed, presentation is idle, every content block is

* final, and every tool call has its matching result.

*/

private hasCompleteToolResultsForCurrentTurn(): boolean {

// Do not require currentStreamingContentIndex to reach the end here.

// A non-abort presenter rejection releases the lock and is logged, but

// nothing schedules another presentation pass. Gating on the index would

// strand this wait after exactly that failure.

if (!this.didCompleteReadingStream || this.dispatchState !== DispatchState.IDLE) {

return false

}

const toolResultIds = new Set(

this.userMessageContent

.filter((block): block is Anthropic.ToolResultBlockParam => block.type === "tool_result")

.map((block) => block.tool_use_id),

)

let toolUseCount = 0

for (const block of this.assistantMessageContent) {

if (block.partial) {

return false

}

if (block.type !== "tool_use" && block.type !== "mcp_tool_use") {

continue

}

toolUseCount++

if (!block.id || !toolResultIds.has(sanitizeToolUseId(block.id))) {

return false

}

}

return toolUseCount > 0

}

didRejectTool = false

didAlreadyUseTool = false

didToolFailInCurrentTurn = false

didCompleteReadingStream = false

private _started = false

private _runPromise: Promise<void> | undefined

private readonly _isHistoryTask: boolean

// No streaming parser is required.

assistantMessageParser?: undefined

// Native tool call streaming state (track which index each tool is at)

private streamingToolCallIndices: Map<string, number> = new Map()

// Cached model info for current streaming session (set at start of each API request)

// This prevents excessive getModel() calls during tool execution

cachedStreamingModel?: { id: string; info: ModelInfo }

// Token Usage Cache

private tokenUsageSnapshot?: TokenUsage

private tokenUsageSnapshotAt?: number

// Tool Usage Cache

private toolUsageSnapshot?: ToolUsage

// Token Usage Throttling - Debounced emit function

private readonly TOKEN_USAGE_EMIT_INTERVAL_MS = 2000 // 2 seconds

private debouncedEmitTokenUsage: ReturnType<typeof debounce>

// Historical cloud sync tracking retained only to avoid task resume churn.

private cloudSyncedMessageTimestamps: Set<number> = new Set()

// Initial status for the task's history item (set at creation time to avoid race conditions)

private readonly initialStatus?: "active" | "delegated" | "completed" | "interrupted"

private pendingAction?: PendingTaskAction

// MessageManager for high-level message operations (lazy initialized)

private _messageManager?: MessageManager

constructor({

provider,

apiConfiguration,

enableCheckpoints = true,

checkpointTimeout = DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,

consecutiveMistakeLimit = DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,

toolRepetitionSoftLimit = DEFAULT_TOOL_REPETITION_SOFT_LIMIT,

taskId,

task,

images,

historyItem,

experiments: _experimentsConfig,

startTask = true,

rootTask,

parentTask,

taskNumber = -1,

onCreated,

initialTodos,

workspacePath,

initialStatus,

rateLimitClock,

diffFuzzyThreshold,

handoffExecutionContext,

}: TaskOptions) {

super()

this.resetAssistantMessagePersistence()

if (startTask && !task && !images && !historyItem) {

throw new Error("Either historyItem or task/images must be provided")

}

if (

!checkpointTimeout ||

checkpointTimeout > MAX_CHECKPOINT_TIMEOUT_SECONDS ||

checkpointTimeout < MIN_CHECKPOINT_TIMEOUT_SECONDS

) {

throw new Error(

"checkpointTimeout must be between " +

MIN_CHECKPOINT_TIMEOUT_SECONDS +

" and " +

MAX_CHECKPOINT_TIMEOUT_SECONDS +

" seconds",

)

}

this.taskId = historyItem ? historyItem.id : (taskId ?? uuidv7())

this.rootTaskId = historyItem ? historyItem.rootTaskId : rootTask?.taskId

this.parentTaskId = historyItem ? historyItem.parentTaskId : parentTask?.taskId

this.childTaskId = undefined

this.metadata = {

task: historyItem ? historyItem.task : task,

images: historyItem ? [] : images,

}

this._isHistoryTask = !!historyItem && !task && !images

// Normal use-case is usually retry similar history task with new workspace.

this.workspacePath = parentTask

? parentTask.workspacePath

: (workspacePath ?? getWorkspacePath(path.join(os.homedir(), "Desktop")))

this.instanceId = crypto.randomUUID().slice(0, 8)

this.taskNumber = -1

this.rooIgnoreController = new RooIgnoreController(this.cwd)

this.rooProtectedController = new RooProtectedController(this.cwd)

this.fileContextTracker = new FileContextTracker(provider, this.taskId)

this.rooIgnoreController.initialize().catch((error) => {

console.error("Failed to initialize RooIgnoreController:", error)

})

this.apiConfiguration = handoffExecutionContext?.apiConfiguration ?? apiConfiguration

this.api = buildApiHandler(this.apiConfiguration)

this.rateLimitClock = rateLimitClock ?? createRateLimitClock()

this.autoApprovalHandler = new AutoApprovalHandler()

this.consecutiveMistakeLimit = consecutiveMistakeLimit ?? DEFAULT_CONSECUTIVE_MISTAKE_LIMIT

this.toolRepetitionSoftLimit = normalizeToolRepetitionSoftLimit(

toolRepetitionSoftLimit ?? DEFAULT_TOOL_REPETITION_SOFT_LIMIT,

this.consecutiveMistakeLimit,

)

this.providerRef = new WeakRef(provider)

this.globalStoragePath = provider.context.globalStorageUri.fsPath

this.divergenceCheckEnabled = isDivergenceCheckEnabled(Package.releaseChannel, provider.context.extensionMode)

this.diffViewProvider = new DiffViewProvider(this.cwd, this)

this.enableCheckpoints = enableCheckpoints

this.checkpointTimeout = checkpointTimeout

this.parentTask = parentTask

this.taskNumber = taskNumber

this.initialStatus = initialStatus ?? historyItem?.status

this.pendingAction = historyItem?.pendingAction

// Store the task's mode and API config name when it's created.

// For history items, use the stored values; for new tasks, we'll set them

// after getting state.

if (handoffExecutionContext) {

this._taskMode = handoffExecutionContext.mode

this._taskApiConfigName = handoffExecutionContext.apiConfigName

this.taskModeReady = Promise.resolve()

this.taskApiConfigReady = Promise.resolve()

TelemetryService.instance.captureTaskCreated(this.taskId)

} else if (historyItem) {

this._taskMode = historyItem.mode || defaultModeSlug

this._taskApiConfigName = historyItem.apiConfigName

this.taskModeReady = Promise.resolve()

this.taskApiConfigReady = Promise.resolve()

TelemetryService.instance.captureTaskRestarted(this.taskId)

} else {

// For new tasks, don't set the mode/apiConfigName yet - wait for async initialization.

this._taskMode = undefined

this._taskApiConfigName = undefined

this.taskModeReady = this.initializeTaskMode(provider)

this.taskApiConfigReady = this.initializeTaskApiConfigName(provider)

TelemetryService.instance.captureTaskCreated(this.taskId)

}

this.assistantMessageParser = undefined

this.messageQueueService = new MessageQueueService()

this.messageQueueStateChangedHandler = () => {

this.emit(RooCodeEventName.TaskUserMessage, this.taskId)

this.emit(RooCodeEventName.QueuedMessagesUpdated, this.taskId, this.messageQueueService.messages)

void this.providerRef

.deref()

?.postStateToWebviewThrottled()

.catch((error) => {

console.error("[Task#messageQueueStateChangedHandler] postStateToWebviewThrottled failed:", error)

})

}

this.messageQueueService.on("stateChanged", this.messageQueueStateChangedHandler)

// Set up diff strategy

this.diffStrategy = new MultiSearchReplaceDiffStrategy(diffFuzzyThreshold)

this.toolRepetitionDetector = new ToolRepetitionDetector(

this.toolRepetitionSoftLimit,

this.consecutiveMistakeLimit,

)

// Initialize todo list if provided

if (initialTodos && initialTodos.length > 0) {

this.todoList = initialTodos

}

// Initialize debounced token usage emit function

// Uses debounce with maxWait to achieve throttle-like behavior:

// - leading: true - Emit immediately on first call

// - trailing: true - Emit final state when updates stop

// - maxWait - Ensures at most one emit per interval during rapid updates (throttle behavior)

this.debouncedEmitTokenUsage = debounce(

(tokenUsage: TokenUsage, toolUsage: ToolUsage) => {

const tokenChanged = hasTokenUsageChanged(tokenUsage, this.tokenUsageSnapshot)

const toolChanged = hasToolUsageChanged(toolUsage, this.toolUsageSnapshot)

if (tokenChanged || toolChanged) {

this.emit(RooCodeEventName.TaskTokenUsageUpdated, this.taskId, tokenUsage, toolUsage)

this.tokenUsageSnapshot = tokenUsage

this.tokenUsageSnapshotAt = this.clineMessages.at(-1)?.ts

// Deep copy tool usage for snapshot

this.toolUsageSnapshot = JSON.parse(JSON.stringify(toolUsage))

}

},

this.TOKEN_USAGE_EMIT_INTERVAL_MS,

{ leading: true, trailing: true, maxWait: this.TOKEN_USAGE_EMIT_INTERVAL_MS },

)

onCreated?.(this)

if (startTask) {

this._started = true

this.startIdleTelemetryCheck()

if (task || images) {

void this.startTask(task, images).catch((error) => {

console.error("[Task#constructor] startTask failed:", error)

})

} else if (historyItem) {

void this.resumeTaskFromHistory().catch((error) => {

console.error("[Task#constructor] resumeTaskFromHistory failed:", error)

})

} else {

throw new Error("Either historyItem or task/images must be provided")

}

}

}

/**

* Initialize the task mode from the provider state.

* This method handles async initialization with proper error handling.

*

* ## Flow

* 1. Attempts to fetch the current mode from provider state

* 2. Sets `_taskMode` to the fetched mode or `defaultModeSlug` if unavailable

* 3. Handles errors gracefully by falling back to default mode

* 4. Logs any initialization errors for debugging

*

* ## Error handling

* - Network failures when fetching provider state

* - Provider not yet initialized

* - Invalid state structure

*

* All errors result in fallback to `defaultModeSlug` to ensure task can proceed.

*

* @private

* @param provider - The ClineProvider instance to fetch state from

* @returns Promise that resolves when initialization is complete

*/

private async initializeTaskMode(provider: ClineProvider): Promise<void> {

try {

const state = await provider.getState()

this._taskMode = state?.mode || defaultModeSlug

} catch (error) {

// If there's an error getting state, use the default mode

this._taskMode = defaultModeSlug

// Use the provider's log method for better error visibility

const errorMessage = `Failed to initialize task mode: ${error instanceof Error ? error.message : String(error)}`

provider.log(errorMessage)

}

}

/**

* Initialize the task API config name from the provider state.

* This method handles async initialization with proper error handling.

*

* ## Flow

* 1. Attempts to fetch the current API config name from provider state

* 2. Sets `_taskApiConfigName` to the fetched name or "default" if unavailable

* 3. Handles errors gracefully by falling back to "default"

* 4. Logs any initialization errors for debugging

*

* ## Error handling

* - Network failures when fetching provider state

* - Provider not yet initialized

* - Invalid state structure

*

* All errors result in fallback to "default" to ensure task can proceed.

*

* @private

* @param provider - The ClineProvider instance to fetch state from

* @returns Promise that resolves when initialization is complete

*/

private async initializeTaskApiConfigName(provider: ClineProvider): Promise<void> {

try {

const state = await provider.getState()

// Avoid clobbering a newer value that may have been set while awaiting provider state

// (e.g., user switches provider profile immediately after task creation).

if (this._taskApiConfigName === undefined) {

this._taskApiConfigName = state?.currentApiConfigName ?? "default"

}

} catch (error) {

// If there's an error getting state, use the default profile (unless a newer value was set).

if (this._taskApiConfigName === undefined) {

this._taskApiConfigName = "default"

}

// Use the provider's log method for better error visibility

const errorMessage = `Failed to initialize task API config name: ${error instanceof Error ? error.message : String(error)}`

provider.log(errorMessage)

}

}

/**

* Wait for the task mode to be initialized before proceeding.

* This method ensures that any operations depending on the task mode

* will have access to the correct mode value.

*

* ## When to use

* - Before accessing mode-specific configurations

* - When switching between tasks with different modes

* - Before operations that depend on mode-based permissions

*

* ## Example usage

* ```typescript

* // Wait for mode initialization before mode-dependent operations

* await task.waitForModeInitialization();

* const mode = task.taskMode; // Now safe to access synchronously

*

* // Or use with getTaskMode() for a one-liner

* const mode = await task.getTaskMode(); // Internally waits for initialization

* ```

*

* @returns Promise that resolves when the task mode is initialized

* @public

*/

public async waitForModeInitialization(): Promise<void> {

return this.taskModeReady

}

/**

* Get the task mode asynchronously, ensuring it's properly initialized.

* This is the recommended way to access the task mode as it guarantees

* the mode is available before returning.