TextGenerationLoop

Get the unresolved tool calls in the latest assistant turn, plus the ids already answered.

Append a resume's tool results, merging into the pause turn's partial results so one assistant turn keeps one answering message.

Settle unresolved historical tool calls so the history remains replayable, optionally leaving the latest assistant turn for a resume to decide.

Find the index of the latest assistant message, or the message count when there is none.

Build pending approval requests for the given tool calls.

Get the milliseconds elapsed since the given monotonic nanosecond reading.

Execute the given tool with the given arguments.

Find a tool by its name from the given tools array.

Join reasoning blocks, separating each block with a blank line.

Create a new text generation loop instance.

Generate a response through model and tool steps.

Stream a response through model and tool steps.

Get the runtime and declared middleware wrapping each generation step.

Each middleware receives a StepResult from $next, whether the inner layer streamed, short-circuited or replaced the step.

Normalize a middleware result to a step result.

Send the prepared step to the model, reporting its start and any synchronous failure.

A step that middleware answered itself was never attempted and reports nothing.

Report a failed generation attempt when one was made.

A continuation replays only unchanged history, model and instructions.

The stream events describing a step response that was produced without streaming.

Resolve the step budget: explicit maxSteps, else 1.5x tools capped at the ceiling, else 5.

Tool results to continue the loop with, plus any pending approvals that pause it.

The early outcome for steps that pause or execute nothing, or null when tools should run.

Get tool results while streaming sub-agent activity.

Report the output a still running tool has produced so far.

Execute a sub-agent tool, streaming its activity while reporting through the run context.

Run the executable tools and collect any pending approvals.

Execute the resolved tool call, or mark it as repaired or exhausted when it can no longer run.

Execute the tool for the given call, returning a failure to the model instead of ending the run.

Get the result the model receives for a tool that threw.

Answer the recorded step with the result its tool just produced.

Create a tool result for the given tool call.

Split the step's tool calls into executable [ToolCall, Tool] pairs and pending approvals.

The names of the locally executable tools, as advertised back to a model that called an unknown one.

Apply the approval's decisions to the pending pause, returning the updated history and resume state.

Claim the pending calls and record each decision's outcome before executing the next.

Determine whether the history ends in a pause a real run could have left: every pending call is for a tool the agent still has, and at least one of them asks for approval.

Find the tool each pending call is for, keyed by the call's id.

Validate the approval's decisions against the pending tool calls, throwing on any mismatch.

Resolve the approval requirement for a tool call, or null when it is not gated.

Generate a unique stream event ID.

Build an assistant message from the given step response.

Build the recorded step from its provider response.

Build the response for a run that ended before any step completed.

Build the final text response from all generated steps.

Ensure at most one tool search wrapper is registered per request.

Drop provider tools the provider cannot run, unwrapping tool search into its deferred tools.