cwd: string

tools: Tools

commands: Command[]

mcpClients: MCPServerConnection[]

agents: AgentDefinition[]

canUseTool: CanUseToolFn

getAppState: () => AppState

setAppState: (f: (prev: AppState) => AppState) => void

initialMessages?: Message[]

readFileCache: FileStateCache

customSystemPrompt?: string

appendSystemPrompt?: string

userSpecifiedModel?: string

fallbackModel?: string

thinkingConfig?: ThinkingConfig

maxTurns?: number

maxBudgetUsd?: number

taskBudget?: { total: number }

jsonSchema?: Record<string, unknown>

verbose?: boolean

replayUserMessages?: boolean

/** Handler for URL elicitations triggered by MCP tool -32042 errors. */

handleElicitation?: ToolUseContext['handleElicitation']

includePartialMessages?: boolean

setSDKStatus?: (status: SDKStatus) => void

abortController?: AbortController

orphanedPermission?: OrphanedPermission

/**

snipReplay?: (

yieldedSystemMsg: Message,

store: Message[],

) => { messages: Message[]; executed: boolean } | undefined

private config: QueryEngineConfig

private mutableMessages: Message[]

private abortController: AbortController

private permissionDenials: SDKPermissionDenial[]

private totalUsage: NonNullableUsage

private hasHandledOrphanedPermission = false

private readFileState: FileStateCache

// Turn-scoped skill discovery tracking (feeds was_discovered on

// tengu_skill_tool_invocation). Must persist across the two

// processUserInputContext rebuilds inside submitMessage, but is cleared

// at the start of each submitMessage to avoid unbounded growth across

// many turns in SDK mode.

private discoveredSkillNames = new Set<string>()

private loadedNestedMemoryPaths = new Set<string>()

constructor(config: QueryEngineConfig) {

this.config = config

this.mutableMessages = config.initialMessages ?? []

this.abortController = config.abortController ?? createAbortController()

this.permissionDenials = []

this.readFileState = config.readFileCache

this.totalUsage = EMPTY_USAGE

}

async *submitMessage(

prompt: string | ContentBlockParam[],

options?: { uuid?: string; isMeta?: boolean },

): AsyncGenerator<SDKMessage, void, unknown> {

const {

cwd,

commands,

tools,

mcpClients,

verbose = false,

thinkingConfig,

maxTurns,

maxBudgetUsd,

taskBudget,

canUseTool,

customSystemPrompt,

appendSystemPrompt,

userSpecifiedModel,

fallbackModel,

jsonSchema,

getAppState,

setAppState,

replayUserMessages = false,

includePartialMessages = false,

agents = [],

setSDKStatus,

orphanedPermission,

} = this.config

this.discoveredSkillNames.clear()

setCwd(cwd)

const persistSession = !isSessionPersistenceDisabled()

const startTime = Date.now()

// Wrap canUseTool to track permission denials

const wrappedCanUseTool: CanUseToolFn = async (

tool,

input,

toolUseContext,

assistantMessage,

toolUseID,

forceDecision,

) => {

const result = await canUseTool(

tool,

input,

toolUseContext,

assistantMessage,

toolUseID,

forceDecision,

)

// Track denials for SDK reporting

if (result.behavior !== 'allow') {

this.permissionDenials.push({

type: 'permission_denial',

tool_name: sdkCompatToolName(tool.name),

tool_use_id: toolUseID,

tool_input: input,

})

}

return result

}

const initialAppState = getAppState()

const initialMainLoopModel = userSpecifiedModel

? parseUserSpecifiedModel(userSpecifiedModel)

: getMainLoopModel()

const initialThinkingConfig: ThinkingConfig = thinkingConfig

? thinkingConfig

: shouldEnableThinkingByDefault() !== false

? { type: 'adaptive' }

: { type: 'disabled' }

headlessProfilerCheckpoint('before_getSystemPrompt')

// Narrow once so TS tracks the type through the conditionals below.

const customPrompt =

typeof customSystemPrompt === 'string' ? customSystemPrompt : undefined

const {

defaultSystemPrompt,

userContext: baseUserContext,

systemContext,

} = await fetchSystemPromptParts({

tools,

mainLoopModel: initialMainLoopModel,

additionalWorkingDirectories: Array.from(

initialAppState.toolPermissionContext.additionalWorkingDirectories.keys(),

),

mcpClients,

customSystemPrompt: customPrompt,

})

headlessProfilerCheckpoint('after_getSystemPrompt')

const userContext = {

...baseUserContext,

...getCoordinatorUserContext(

mcpClients,

isScratchpadEnabled() ? getScratchpadDir() : undefined,

),

}

// When an SDK caller provides a custom system prompt AND has set

// CLAUDE_COWORK_MEMORY_PATH_OVERRIDE, inject the memory-mechanics prompt.

// The env var is an explicit opt-in signal — the caller has wired up

// a memory directory and needs Claude to know how to use it (which

// Write/Edit tools to call, MEMORY.md filename, loading semantics).

// The caller can layer their own policy text via appendSystemPrompt.

const memoryMechanicsPrompt =

customPrompt !== undefined && hasAutoMemPathOverride()

? await loadMemoryPrompt()

: null

const systemPrompt = asSystemPrompt([

...(customPrompt !== undefined ? [customPrompt] : defaultSystemPrompt),

...(memoryMechanicsPrompt ? [memoryMechanicsPrompt] : []),

...(appendSystemPrompt ? [appendSystemPrompt] : []),

])

// Register function hook for structured output enforcement

const hasStructuredOutputTool = tools.some(t =>

toolMatchesName(t, SYNTHETIC_OUTPUT_TOOL_NAME),

)

if (jsonSchema && hasStructuredOutputTool) {

registerStructuredOutputEnforcement(setAppState, getSessionId())

}

let processUserInputContext: ProcessUserInputContext = {

messages: this.mutableMessages,

// Slash commands that mutate the message array (e.g. /force-snip)

// call setMessages(fn). In interactive mode this writes back to

// AppState; in print mode we write back to mutableMessages so the

// rest of the query loop (push at :389, snapshot at :392) sees

// the result. The second processUserInputContext below (after

// slash-command processing) keeps the no-op — nothing else calls

// setMessages past that point.

setMessages: fn => {

this.mutableMessages = fn(this.mutableMessages)

},

onChangeAPIKey: () => {},

handleElicitation: this.config.handleElicitation,

options: {

commands,

debug: false, // we use stdout, so don't want to clobber it

tools,

verbose,

mainLoopModel: initialMainLoopModel,

thinkingConfig: initialThinkingConfig,

mcpClients,

mcpResources: {},

ideInstallationStatus: null,

isNonInteractiveSession: true,

customSystemPrompt,

appendSystemPrompt,

agentDefinitions: { activeAgents: agents, allAgents: [] },

theme: resolveThemeSetting(getGlobalConfig().theme),

maxBudgetUsd,

},

getAppState,

setAppState,

abortController: this.abortController,

readFileState: this.readFileState,

nestedMemoryAttachmentTriggers: new Set<string>(),

loadedNestedMemoryPaths: this.loadedNestedMemoryPaths,

dynamicSkillDirTriggers: new Set<string>(),

discoveredSkillNames: this.discoveredSkillNames,

setInProgressToolUseIDs: () => {},

setResponseLength: () => {},

updateFileHistoryState: (

updater: (prev: FileHistoryState) => FileHistoryState,

) => {

setAppState(prev => {

const updated = updater(prev.fileHistory)

if (updated === prev.fileHistory) return prev

return { ...prev, fileHistory: updated }

})

},

updateAttributionState: (

updater: (prev: AttributionState) => AttributionState,

) => {

setAppState(prev => {

const updated = updater(prev.attribution)

if (updated === prev.attribution) return prev

return { ...prev, attribution: updated }

})

},

setSDKStatus,

}

// Handle orphaned permission (only once per engine lifetime)

if (orphanedPermission && !this.hasHandledOrphanedPermission) {

this.hasHandledOrphanedPermission = true

for await (const message of handleOrphanedPermission(

orphanedPermission,

tools,

this.mutableMessages,

processUserInputContext,

)) {

yield message

}

}

const {

messages: messagesFromUserInput,

shouldQuery,

allowedTools,

model: modelFromUserInput,

resultText,

} = await processUserInput({

input: prompt,

mode: 'prompt',

setToolJSX: () => {},

context: {

...processUserInputContext,

messages: this.mutableMessages,

},

messages: this.mutableMessages,

uuid: options?.uuid,

isMeta: options?.isMeta,

querySource: 'sdk',

})

// Push new messages, including user input and any attachments

this.mutableMessages.push(...messagesFromUserInput)

// Update params to reflect updates from processing /slash commands

const messages = [...this.mutableMessages]

// Persist the user's message(s) to transcript BEFORE entering the query

// loop. The for-await below only calls recordTranscript when ask() yields

// an assistant/user/compact_boundary message — which doesn't happen until

// the API responds. If the process is killed before that (e.g. user clicks

// Stop in cowork seconds after send), the transcript is left with only

// queue-operation entries; getLastSessionLog filters those out, returns

// null, and --resume fails with "No conversation found". Writing now makes

// the transcript resumable from the point the user message was accepted,

// even if no API response ever arrives.

//

// --bare / SIMPLE: fire-and-forget. Scripted calls don't --resume after

// kill-mid-request. The await is ~4ms on SSD, ~30ms under disk contention

// — the single largest controllable critical-path cost after module eval.

// Transcript is still written (for post-hoc debugging); just not blocking.

if (persistSession && messagesFromUserInput.length > 0) {

const transcriptPromise = recordTranscript(messages)

if (isBareMode()) {

void transcriptPromise

} else {

await transcriptPromise

if (

isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||

isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)

) {

await flushSessionStorage()

}

}

}

// Filter messages that should be acknowledged after transcript

const replayableMessages = messagesFromUserInput.filter(

msg =>

(msg.type === 'user' &&

!msg.isMeta && // Skip synthetic caveat messages

!msg.toolUseResult && // Skip tool results (they'll be acked from query)

messageSelector().selectableUserMessagesFilter(msg)) || // Skip non-user-authored messages (task notifications, etc.)

(msg.type === 'system' && msg.subtype === 'compact_boundary'), // Always ack compact boundaries

)

const messagesToAck = replayUserMessages ? replayableMessages : []

// Update the ToolPermissionContext based on user input processing (as necessary)

setAppState(prev => ({

...prev,

toolPermissionContext: {

...prev.toolPermissionContext,

alwaysAllowRules: {

...prev.toolPermissionContext.alwaysAllowRules,

command: allowedTools,

},

},

}))

const mainLoopModel = modelFromUserInput ?? initialMainLoopModel

// Recreate after processing the prompt to pick up updated messages and

// model (from slash commands).

processUserInputContext = {

messages,

setMessages: () => {},

onChangeAPIKey: () => {},

handleElicitation: this.config.handleElicitation,

options: {

commands,

debug: false,

tools,

verbose,

mainLoopModel,

thinkingConfig: initialThinkingConfig,

mcpClients,

mcpResources: {},

ideInstallationStatus: null,

isNonInteractiveSession: true,

customSystemPrompt,

appendSystemPrompt,

theme: resolveThemeSetting(getGlobalConfig().theme),

agentDefinitions: { activeAgents: agents, allAgents: [] },

maxBudgetUsd,

},

getAppState,

setAppState,

abortController: this.abortController,

readFileState: this.readFileState,

nestedMemoryAttachmentTriggers: new Set<string>(),

loadedNestedMemoryPaths: this.loadedNestedMemoryPaths,

dynamicSkillDirTriggers: new Set<string>(),

discoveredSkillNames: this.discoveredSkillNames,

setInProgressToolUseIDs: () => {},

setResponseLength: () => {},

updateFileHistoryState: processUserInputContext.updateFileHistoryState,

updateAttributionState: processUserInputContext.updateAttributionState,

setSDKStatus,

}

headlessProfilerCheckpoint('before_skills_plugins')

// Cache-only: headless/SDK/CCR startup must not block on network for

// ref-tracked plugins. CCR populates the cache via CLAUDE_CODE_SYNC_PLUGIN_INSTALL

// (headlessPluginInstall) or CLAUDE_CODE_PLUGIN_SEED_DIR before this runs;

// SDK callers that need fresh source can call /reload-plugins.

const [skills, { enabled: enabledPlugins }] = await Promise.all([

getSlashCommandToolSkills(getCwd()),

loadAllPluginsCacheOnly(),

])

headlessProfilerCheckpoint('after_skills_plugins')

yield buildSystemInitMessage({

tools,

mcpClients,

model: mainLoopModel,

permissionMode: initialAppState.toolPermissionContext

.mode as PermissionMode, // TODO: avoid the cast

commands,

agents,

skills,

plugins: enabledPlugins,

fastMode: initialAppState.fastMode,

})

// Record when system message is yielded for headless latency tracking

headlessProfilerCheckpoint('system_message_yielded')

if (!shouldQuery) {

// Return the results of local slash commands.

// Use messagesFromUserInput (not replayableMessages) for command output

// because selectableUserMessagesFilter excludes local-command-stdout tags.

for (const msg of messagesFromUserInput) {

if (

msg.type === 'user' &&

typeof msg.message.content === 'string' &&

(msg.message.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`) ||

msg.message.content.includes(`<${LOCAL_COMMAND_STDERR_TAG}>`) ||

msg.isCompactSummary)

) {

yield {

type: 'user',

message: {

...msg.message,

content: stripAnsi(msg.message.content),

},

session_id: getSessionId(),

parent_tool_use_id: null,

uuid: msg.uuid,

timestamp: msg.timestamp,

isReplay: !msg.isCompactSummary,

isSynthetic: msg.isMeta || msg.isVisibleInTranscriptOnly,

} as unknown as SDKUserMessageReplay

}

// Local command output — yield as a synthetic assistant message so

// RC renders it as assistant-style text rather than a user bubble.

// Emitted as assistant (not the dedicated SDKLocalCommandOutputMessage

// system subtype) so mobile clients + session-ingress can parse it.

if (

msg.type === 'system' &&

msg.subtype === 'local_command' &&

typeof msg.content === 'string' &&

(msg.content.includes(`<${LOCAL_COMMAND_STDOUT_TAG}>`) ||

msg.content.includes(`<${LOCAL_COMMAND_STDERR_TAG}>`))

) {

yield localCommandOutputToSDKAssistantMessage(msg.content, msg.uuid)

}

if (msg.type === 'system' && msg.subtype === 'compact_boundary') {

const compactMsg = msg as SystemCompactBoundaryMessage

yield {

type: 'system',

subtype: 'compact_boundary' as const,

session_id: getSessionId(),

uuid: msg.uuid,

compact_metadata: toSDKCompactMetadata(compactMsg.compactMetadata),

} as unknown as SDKCompactBoundaryMessage

}

}

if (persistSession) {

await recordTranscript(messages)

if (

isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||

isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)

) {

await flushSessionStorage()

}

}

yield {

type: 'result',

subtype: 'success',

is_error: false,

duration_ms: Date.now() - startTime,

duration_api_ms: getTotalAPIDuration(),

num_turns: messages.length - 1,

result: resultText ?? '',

stop_reason: null,

session_id: getSessionId(),

total_cost_usd: getTotalCost(),

usage: this.totalUsage,

modelUsage: getModelUsage(),

permission_denials: this.permissionDenials,

fast_mode_state: getFastModeState(

mainLoopModel,

initialAppState.fastMode,

),

uuid: randomUUID(),

}

return

}

if (fileHistoryEnabled() && persistSession) {

messagesFromUserInput

.filter(messageSelector().selectableUserMessagesFilter)

.forEach(message => {

void fileHistoryMakeSnapshot(

(updater: (prev: FileHistoryState) => FileHistoryState) => {

setAppState(prev => ({

...prev,

fileHistory: updater(prev.fileHistory),

}))

},

message.uuid,

)

})

}

// Track current message usage (reset on each message_start)

let currentMessageUsage: NonNullableUsage = EMPTY_USAGE

let turnCount = 1

let hasAcknowledgedInitialMessages = false

// Track structured output from StructuredOutput tool calls

let structuredOutputFromTool: unknown

// Track the last stop_reason from assistant messages

let lastStopReason: string | null = null

// Reference-based watermark so error_during_execution's errors[] is

// turn-scoped. A length-based index breaks when the 100-entry ring buffer

// shift()s during the turn — the index slides. If this entry is rotated

// out, lastIndexOf returns -1 and we include everything (safe fallback).

const errorLogWatermark = getInMemoryErrors().at(-1)

// Snapshot count before this query for delta-based retry limiting

const initialStructuredOutputCalls = jsonSchema

? countToolCalls(this.mutableMessages, SYNTHETIC_OUTPUT_TOOL_NAME)

: 0

for await (const message of query({

messages,

systemPrompt,

userContext,

systemContext,

canUseTool: wrappedCanUseTool,

toolUseContext: processUserInputContext,

fallbackModel,

querySource: 'sdk',

maxTurns,

taskBudget,

})) {

// Record assistant, user, and compact boundary messages

if (

message.type === 'assistant' ||

message.type === 'user' ||

(message.type === 'system' && message.subtype === 'compact_boundary')

) {

// Before writing a compact boundary, flush any in-memory-only

// messages up through the preservedSegment tail. Attachments and

// progress are now recorded inline (their switch cases below), but

// this flush still matters for the preservedSegment tail walk.

// If the SDK subprocess restarts before then (claude-desktop kills

// between turns), tailUuid points to a never-written message →

// applyPreservedSegmentRelinks fails its tail→head walk → returns

// without pruning → resume loads full pre-compact history.

if (

persistSession &&

message.type === 'system' &&

message.subtype === 'compact_boundary'

) {

const compactMsg = message as SystemCompactBoundaryMessage

const tailUuid = compactMsg.compactMetadata?.preservedSegment?.tailUuid

if (tailUuid) {

const tailIdx = this.mutableMessages.findLastIndex(

m => m.uuid === tailUuid,

)

if (tailIdx !== -1) {

await recordTranscript(this.mutableMessages.slice(0, tailIdx + 1))

}

}

}

messages.push(message as Message)

if (persistSession) {

// Fire-and-forget for assistant messages. claude.ts yields one

// assistant message per content block, then mutates the last

// one's message.usage/stop_reason on message_delta — relying on

// the write queue's 100ms lazy jsonStringify. Awaiting here

// blocks ask()'s generator, so message_delta can't run until

// every block is consumed; the drain timer (started at block 1)

// elapses first. Interactive CC doesn't hit this because

// useLogMessages.ts fire-and-forgets. enqueueWrite is

// order-preserving so fire-and-forget here is safe.

if (message.type === 'assistant') {

void recordTranscript(messages)

} else {

await recordTranscript(messages)

}

}

// Acknowledge initial user messages after first transcript recording

if (!hasAcknowledgedInitialMessages && messagesToAck.length > 0) {

hasAcknowledgedInitialMessages = true

for (const msgToAck of messagesToAck) {

if (msgToAck.type === 'user') {

yield {

type: 'user',

message: msgToAck.message,

session_id: getSessionId(),

parent_tool_use_id: null,

uuid: msgToAck.uuid,

timestamp: msgToAck.timestamp,

isReplay: true,

} as unknown as SDKUserMessageReplay

}

}

}

}

if (message.type === 'user') {

turnCount++

}

switch (message.type) {

case 'tombstone':

// Tombstone messages are control signals for removing messages, skip them

break

case 'assistant': {

// Capture stop_reason if already set (synthetic messages). For

// streamed responses, this is null at content_block_stop time;

// the real value arrives via message_delta (handled below).

const msg = message as Message

const stopReason = msg.message?.stop_reason as string | null | undefined

if (stopReason != null) {

lastStopReason = stopReason

}

this.mutableMessages.push(msg)

yield* normalizeMessage(msg)

break

}

case 'progress': {

const msg = message as Message

this.mutableMessages.push(msg)

// Record inline so the dedup loop in the next ask() call sees it

// as already-recorded. Without this, deferred progress interleaves

// with already-recorded tool_results in mutableMessages, and the

// dedup walk freezes startingParentUuid at the wrong message —

// forking the chain and orphaning the conversation on resume.

if (persistSession) {

messages.push(msg)

void recordTranscript(messages)

}

yield* normalizeMessage(msg)

break

}

case 'user': {

const msg = message as Message

this.mutableMessages.push(msg)

yield* normalizeMessage(msg)

break

}

case 'stream_event': {

const event = (message as unknown as { event: Record<string, unknown> }).event

if (event.type === 'message_start') {

// Reset current message usage for new message

currentMessageUsage = EMPTY_USAGE

const eventMessage = event.message as { usage: BetaMessageDeltaUsage }

currentMessageUsage = updateUsage(

currentMessageUsage,

eventMessage.usage,

)

}

if (event.type === 'message_delta') {

currentMessageUsage = updateUsage(

currentMessageUsage,

event.usage as BetaMessageDeltaUsage,

)

// Capture stop_reason from message_delta. The assistant message

// is yielded at content_block_stop with stop_reason=null; the

// real value only arrives here (see claude.ts message_delta

// handler). Without this, result.stop_reason is always null.

const delta = event.delta as { stop_reason?: string | null }

if (delta.stop_reason != null) {

lastStopReason = delta.stop_reason

}

}

if (event.type === 'message_stop') {

// Accumulate current message usage into total

this.totalUsage = accumulateUsage(

this.totalUsage,

currentMessageUsage,

)

}

if (includePartialMessages) {

yield {

type: 'stream_event' as const,

event,

session_id: getSessionId(),

parent_tool_use_id: null,

uuid: randomUUID(),

}

}

break

}

case 'attachment': {

const msg = message as Message

this.mutableMessages.push(msg)

// Record inline (same reason as progress above).

if (persistSession) {

messages.push(msg)

void recordTranscript(messages)

}

const attachment = msg.attachment as { type: string; data?: unknown; turnCount?: number; maxTurns?: number; prompt?: string; source_uuid?: string; [key: string]: unknown }

// Extract structured output from StructuredOutput tool calls

if (attachment.type === 'structured_output') {

structuredOutputFromTool = attachment.data

}

// Handle max turns reached signal from query.ts

else if (attachment.type === 'max_turns_reached') {

if (persistSession) {

if (

isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||

isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)

) {

await flushSessionStorage()

}

}

yield {

type: 'result',

subtype: 'error_max_turns',

duration_ms: Date.now() - startTime,

duration_api_ms: getTotalAPIDuration(),

is_error: true,

num_turns: attachment.turnCount as number,

stop_reason: lastStopReason,

session_id: getSessionId(),

total_cost_usd: getTotalCost(),

usage: this.totalUsage,

modelUsage: getModelUsage(),

permission_denials: this.permissionDenials,

fast_mode_state: getFastModeState(

mainLoopModel,

initialAppState.fastMode,

),

uuid: randomUUID(),

errors: [

`Reached maximum number of turns (${attachment.maxTurns})`,

],

}

return

}

// Yield queued_command attachments as SDK user message replays

else if (

replayUserMessages &&

attachment.type === 'queued_command'

) {

yield {

type: 'user',

message: {

role: 'user' as const,

content: attachment.prompt,

},

session_id: getSessionId(),

parent_tool_use_id: null,

uuid: attachment.source_uuid || msg.uuid,

timestamp: msg.timestamp,

isReplay: true,

} as unknown as SDKUserMessageReplay

}

break

}

case 'stream_request_start':

// Don't yield stream request start messages

break

case 'system': {

const msg = message as Message

// Snip boundary: replay on our store to remove zombie messages and

// stale markers. The yielded boundary is a signal, not data to push —

// the replay produces its own equivalent boundary. Without this,

// markers persist and re-trigger on every turn, and mutableMessages

// never shrinks (memory leak in long SDK sessions). The subtype

// check lives inside the injected callback so feature-gated strings

// stay out of this file (excluded-strings check).

const snipResult = this.config.snipReplay?.(

msg,

this.mutableMessages,

)

if (snipResult !== undefined) {

if (snipResult.executed) {

this.mutableMessages.length = 0

this.mutableMessages.push(...snipResult.messages)

}

break

}

this.mutableMessages.push(msg)

// Yield compact boundary messages to SDK

if (

msg.subtype === 'compact_boundary' &&

msg.compactMetadata

) {

const compactMsg = msg as SystemCompactBoundaryMessage

// Release pre-compaction messages for GC. The boundary was just

// pushed so it's the last element. query.ts already uses

// getMessagesAfterCompactBoundary() internally, so only

// post-boundary messages are needed going forward.

const mutableBoundaryIdx = this.mutableMessages.length - 1

if (mutableBoundaryIdx > 0) {

this.mutableMessages.splice(0, mutableBoundaryIdx)

}

const localBoundaryIdx = messages.length - 1

if (localBoundaryIdx > 0) {

messages.splice(0, localBoundaryIdx)

}

yield {

type: 'system',

subtype: 'compact_boundary' as const,

session_id: getSessionId(),

uuid: msg.uuid,

compact_metadata: toSDKCompactMetadata(compactMsg.compactMetadata),

}

}

if (msg.subtype === 'api_error') {

const apiErrorMsg = msg as Message & { retryAttempt: number; maxRetries: number; retryInMs: number; error: APIError }

yield {

type: 'system',

subtype: 'api_retry' as const,

attempt: apiErrorMsg.retryAttempt,

max_retries: apiErrorMsg.maxRetries,

retry_delay_ms: apiErrorMsg.retryInMs,

error_status: apiErrorMsg.error.status ?? null,

error: categorizeRetryableAPIError(apiErrorMsg.error),

session_id: getSessionId(),

uuid: msg.uuid,

}

}

// Don't yield other system messages in headless mode

break

}

case 'tool_use_summary': {

const msg = message as Message & { summary: unknown; precedingToolUseIds: unknown }

// Yield tool use summary messages to SDK

yield {

type: 'tool_use_summary' as const,

summary: msg.summary,

preceding_tool_use_ids: msg.precedingToolUseIds,

session_id: getSessionId(),

uuid: msg.uuid,

}

break

}

}

// Check if USD budget has been exceeded

if (maxBudgetUsd !== undefined && getTotalCost() >= maxBudgetUsd) {

if (persistSession) {

if (

isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||