Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/ai-core/src/hooks/useSessionChat.ts`:
- Around line 107-108: Delete the unused ref declaration and assignment for
addToolOutputRef: remove the const addToolOutputRef =
useRef<AddToolOutput>(null!) declaration and any subsequent assignment to
addToolOutputRef, since addToolOutput is already registered with the store (the
addToolOutput function is used directly) and the ref is redundant; ensure any
imports (e.g., useRef) that become unused are cleaned up.

In `@packages/ai-core/src/utils.ts`:
- Around line 308-349: The tail tool-detection in shouldEndAnalysis currently
only checks part.type and can miss tool parts that are waiting for approval;
update the tailHasTool predicate inside shouldEndAnalysis to also treat a tool
part as pending when its state === 'approval-requested' (e.g., check part.state
=== 'approval-requested' alongside type checks), mirroring the pattern used in
fixIncompleteToolCalls; ensure this integrates with the existing use of
lastAssistantMessageIsCompleteWithToolCalls and keep behavior consistent with
lastAssistantMessageIsCompleteWithApprovalResponses for approval flows.

---

Outside diff comments:
In `@packages/ai-core/src/AiSlice.ts`:
- Around line 600-610: deleteSession currently clears several per-session maps
but misses removing entries from sessionAddToolApprovalResponses, causing
potential memory leaks; update the deleteSession method to also call
sessionAddToolApprovalResponses.delete(sessionId) (or clear the map entry)
alongside sessionAddToolOutputs.delete(sessionId) and the other
sessionXXX.delete(sessionId) calls so all per-session handlers are cleaned up
when deleteSession runs.

---

Nitpick comments:
In `@examples/ai-nextjs/src/app/api/chat/route.ts`:
- Around line 11-18: Add a Zod schema and validate the parsed body immediately
after the await req.json() call in the API route handler in route.ts: define a
schema for messages, modelProvider, model, instructions, maxSteps (number),
temperature (number) with appropriate defaults/required flags, parse/parseAsync
the incoming payload, and if validation fails return a 400 response with the
error details; then use the validated/parsed values (instead of raw
destructuring) so downstream logic (e.g., any function expecting numeric
maxSteps or temperature) receives correct types.

In `@packages/ai-core/src/agents/AgentUtils.ts`:
- Around line 73-114: streamSubAgent currently accumulates tool call state in
toolEditState but only returns finalText; change streamSubAgent to return both
the text and the tool call state (e.g., { text: string, toolCalls:
Map<string,AgentToolCall> }) by updating the function return type and final
return value, preserve building toolEditState inside the function, and update
all callers of streamSubAgent (and any type annotations) to handle the new
object shape so callers can access toolCalls for logging/debugging.

In `@packages/ai-core/src/components/ToolCallInfo.tsx`:
- Around line 13-25: ToolCallInfoProps declares an unused isCompleted prop —
remove the isCompleted field from the ToolCallInfoProps type declaration and
update the ToolCallInfo component JSDoc to delete the `@param` props.isCompleted
entry; then remove the isCompleted={isCompleted} prop passed from
ToolPartRenderer (so ToolPartRenderer no longer forwards that unused prop).
Ensure you only change the type, JSDoc, and the prop usage (references:
ToolCallInfoProps, isCompleted, ToolPartRenderer) so the component derives
completion from the existing state prop.

In `@packages/ai-core/src/components/ToolPartRenderer.tsx`:
- Around line 183-188: Remove the now-unused isCompleted prop from the
ToolCallInfo invocation in ToolPartRenderer: update the JSX that renders
<ToolCallInfo ... /> by deleting the isCompleted={isCompleted} prop so the
component is called with only toolName, input, and state; verify ToolCallInfo
props type (in ToolCallInfo.tsx) matches and run type checks to ensure no other
references to isCompleted remain in ToolPartRenderer.

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@packages/ai-core/src/AiSlice.ts`:
- Line 214: The function getMaxStepsFromSettings currently sets its parameter
maxSteps = 50 which causes the first branch to always win and ignores
aiSettings.config.modelParameters.maxSteps; change the parameter so it does not
default to 50 (e.g. accept undefined/null) and implement a proper fallback: if
an explicit maxSteps argument is provided use it, otherwise read
aiSettings.config.modelParameters.maxSteps (and if that is missing use 50 as the
final default). Update getMaxStepsFromSettings and any other occurrences (same
pattern around the block handling lines ~739-754) to follow this precedence:
explicit arg -> aiSettings.config.modelParameters.maxSteps -> 50.
- Around line 651-674: setSessionUiMessages currently returns true even when no
session is found and nothing is written; update the implementation of
setSessionUiMessages to detect whether a matching session was located and only
return true when uiMessages were actually persisted. Specifically, locate the
session lookup in the produce callback (the draft.ai.config.sessions.find call
inside setSessionUiMessages) and add a boolean flag (e.g., "updated") that is
set to true when session.uiMessages is assigned; call set(...) only when
necessary or run it but return the flag value (false if no session matched).
Ensure the function still catches errors and returns false on exceptions but
does not report success when no session was modified.
- Around line 603-613: deleteSession currently fails to remove the per-session
approval-response map, leaving sessionAddToolApprovalResponses entries and
closures alive; update the deleteSession implementation to mirror the other
per-session cleanup (sessionChatStops, sessionChatSendMessages, etc.) by calling
sessionAddToolApprovalResponses.delete(sessionId) when a session is deleted so
the approval-response callbacks are released.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/ai-core/src/agents/AgentUtils.ts`:
- Around line 8-14: The AgentToolCall.type currently restricts state to
'pending' | 'success' | 'error', which omits the new approval-related states;
update the AgentToolCall definition (symbol: AgentToolCall and its state field)
to include 'approval-requested', 'approval-responded', and 'output-denied' in
the state union so tool renderers and approval flows type-check correctly and
handle these new statuses.
- Around line 98-108: The loop in AgentUtils.ts that consumes the streaming
response only appends 'text-delta' chunks and silently ignores
'tool-output-error' and 'tool-input-error' chunks; update the for-await loop
that processes "stream" (and uses throwIfAborted and finalText) to detect error
chunk types (e.g., 'tool-output-error', 'tool-input-error') and immediately
propagate them by throwing an Error (or rethrowing contained error payload)
including the tool error details so the caller sees sub-agent failures instead
of returning partial finalText; ensure the catch block continues to call
throwIfAborted before rethrowing.

In `@packages/ai-core/src/components/ToolCallInfo.tsx`:
- Around line 49-55: The JSX in ToolCallInfo currently treats
'approval-requested' like other in-progress states and renders Loader2
(spinner); change the conditional so 'approval-requested' is excluded from the
spinner branch and instead render a distinct, non-animating indicator for that
state (e.g., use a PauseIcon or a static CircleArrowRightIcon variant) so it
reads as “paused awaiting user action.” Update the conditional logic around the
state check in the ToolCallInfo component (the spots referencing state, Loader2,
and CircleArrowRightIcon) to add an explicit branch for 'approval-requested'
rendering the chosen static icon/class names and remove 'approval-requested'
from the spinner condition.

In `@packages/ai-core/src/hooks/useSessionChat.ts`:
- Around line 120-135: The current seeding of useChat (id, transport, messages:
initialMessages) is losing pending approval requests because
fixIncompleteToolCalls rewrites trailing "approval-requested" parts to
"output-error"; update the flow so approval-requested parts are preserved across
reloads—either by changing fixIncompleteToolCalls (in
packages/ai-core/src/utils.ts) to treat trailing parts with type
"approval-requested" as complete and leave them untouched, or by skipping
fixIncompleteToolCalls for messages that contain an "approval-requested" part
before passing initialMessages into useChat; ensure this touches the helper
fixIncompleteToolCalls and the call site that prepares initialMessages (the code
that seeds useChat) and keep lastAssistantMessageIsCompleteWithApprovalResponses
and isAbortedRef logic unchanged.

---

Outside diff comments:
In `@packages/ai-core/src/AiSlice.ts`:
- Around line 603-613: The deleteSession function currently removes per-session
state but leaves entries in toolCallToSessionId that still map toolCallIds to
the deleted sessionId; update deleteSession to scan the toolCallToSessionId map
(or use an index) and delete any entries whose value === sessionId so late
tool-stream events cannot resolve the removed session and the map does not leak;
locate the deleteSession implementation and remove matching keys from
toolCallToSessionId for the given sessionId.

---

Nitpick comments:
In `@packages/ai-core/src/components/ToolPartRenderer.tsx`:
- Around line 132-145: The conditional that chooses to return the approval/UI
wrapper uses a looser predicate (checking ToolComponent truthiness) than the JSX
renderer (which only renders when ToolComponent is a plain function), causing
memoized/forwardRef components to be skipped; update the branch to use the same
predicate as rendering (or vice-versa) so both use an identical check for
renderability — e.g., ensure the if condition mirrors the JSX guard that checks
ToolComponent && typeof ToolComponent === 'function' (or change both to
React.isValidElementType/explicit registry typing) when evaluating
isApprovalState and hasExecute in ToolPartRenderer (the conditional around
ToolComponent, isApprovalState, hasExecute and the JSX that renders
<ToolComponent/>).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/ai-core/src/agents/AgentUtils.ts`:
- Around line 94-104: Move the awaited createAgentUIStream call into the try
block and call throwIfAborted() immediately before awaiting it so pre-stream
aborts are normalized; specifically, inside the function where you currently
await createAgentUIStream(...) (creating the const stream), remove that await
from before the try, then inside the try call throwIfAborted() and then await
createAgentUIStream(...) to assign stream, so any abort during stream creation
is caught and converted to the ToolAbortError(TOOL_CALL_CANCELLED) handling
path.

In `@packages/ai-core/src/components/ToolPartRenderer.tsx`:
- Around line 132-137: The current ToolPartRenderer returns null when
isApprovalState is true but ToolComponent is missing, which silently hides
approval requests; change this to render a minimal fallback UI (e.g., an inline
ApprovalFallback) that visibly displays the toolName and the approval prompt and
wires into the existing approval handlers so the user can approve/deny; update
the branch that checks isApprovalState && !ToolComponent to return this fallback
element (or call a new renderApprovalFallback function/component) instead of
null and ensure it uses the same props/callback signatures as the real
ToolComponent so the agent loop can continue.

In `@packages/ai-core/src/hooks/useSessionChat.ts`:
- Around line 113-135: The sendAutomaticallyWhen callback only checks
lastAssistantMessageIsCompleteWithApprovalResponses so sessions stall when a
tool returns client-provided output via addToolOutput (no execute); import
lastAssistantMessageIsCompleteWithToolCalls and change sendAutomaticallyWhen to
return true when either
lastAssistantMessageIsCompleteWithApprovalResponses(options) OR
lastAssistantMessageIsCompleteWithToolCalls(options) is true (keeping the
existing isAbortedRef.current guard), so both approval-driven and
tool-output-driven auto-resubmits continue the chat.

In `@packages/ai-core/src/utils.ts`:
- Around line 398-402: The cleanup logic around toolPart state incorrectly
converts valid input-waiting states to 'output-error' when finishing normally;
update fixIncompleteToolCalls (and its callers such as the normal-finish path in
chatTransport.ts) to accept a flag like preserveInputStates or a mode ('abort'
vs 'finish') and, when in the normal finish mode, skip converting states that
start with 'input' (e.g. 'input-streaming', 'input-available') so tools awaiting
client addToolOutput remain unchanged; reference the isCompleted check and
ensure callers using useChat/createAgentUIStreamResponse pass the appropriate
mode so only abort/error flows perform aggressive cancellation.