@@ -132,6 +132,46 @@ function cloneAssistantContent(
132132 });
133133 }
134134
135+interface MergedAssistantBlock {
136+ block: AssistantMessage["content"][number];
137+ partialStep: number;
138+ finalStep: number;
139+}
140+
141+function mergeAssistantBlocks(
142+ partialBlock: AssistantMessage["content"][number] | undefined,
143+ finalBlock: AssistantMessage["content"][number] | undefined,
144+): MergedAssistantBlock | null {
145+ if (!partialBlock && !finalBlock) {
146+ return null;
147+ }
148+ if (!partialBlock && finalBlock) {
149+ return { block: finalBlock, partialStep: 0, finalStep: 1 };
150+ }
151+ if (partialBlock && !finalBlock) {
152+ return { block: partialBlock, partialStep: 1, finalStep: 0 };
153+ }
154+ if (!partialBlock || !finalBlock) {
155+ return null;
156+ }
157+ if (partialBlock.type === finalBlock.type) {
158+ const shouldPreservePartialThinking =
159+ partialBlock.type === "thinking" &&
160+ finalBlock.type === "thinking" &&
161+ partialBlock.thinking &&
162+ !finalBlock.thinking;
163+ return {
164+ block: shouldPreservePartialThinking ? partialBlock : finalBlock,
165+ partialStep: 1,
166+ finalStep: 1,
167+ };
168+ }
169+ if (partialBlock.type === "thinking") {
170+ return { block: partialBlock, partialStep: 1, finalStep: 0 };
171+ }
172+ return { block: finalBlock, partialStep: 1, finalStep: 1 };
173+}
174+
135175 /** Merge streamed partial assistant content into the final message content. */
136176 function mergeAssistantContent(
137177 partialContent: AssistantMessage["content"],
@@ -148,42 +188,16 @@ function mergeAssistantContent(
148188 partialIndex < partialContent.length ||
149189 finalIndex < finalContent.length
150190 ) {
151- const partialBlock = partialContent[partialIndex];
152- const finalBlock = finalContent[finalIndex];
153-
154- if (!partialBlock) {
155- merged.push(finalBlock!);
156- finalIndex++;
157- continue;
158- }
159- if (!finalBlock) {
160- merged.push(partialBlock);
161- partialIndex++;
162- continue;
163- }
164- if (partialBlock.type === finalBlock.type) {
165- if (
166- partialBlock.type === "thinking" &&
167- finalBlock.type === "thinking" &&
168- partialBlock.thinking &&
169- !finalBlock.thinking
170- ) {
171- merged.push(partialBlock);
172- } else {
173- merged.push(finalBlock);
174- }
175- partialIndex++;
176- finalIndex++;
177- continue;
178- }
179- if (partialBlock.type === "thinking") {
180- merged.push(partialBlock);
181- partialIndex++;
182- continue;
191+ const nextBlock = mergeAssistantBlocks(
192+ partialContent[partialIndex],
193+ finalContent[finalIndex],
194+ );
195+ if (!nextBlock) {
196+ break;
183197 }
184- merged.push(finalBlock);
185- partialIndex++;
186- finalIndex++;
198+ merged.push(nextBlock.block);
199+ partialIndex += nextBlock.partialStep;
200+ finalIndex += nextBlock.finalStep;
187201 }
188202
189203 return merged;
@@ -212,6 +226,207 @@ function toolErrorResult(name: string, error: unknown): ToolExecResult {
212226 };
213227 }
214228
229+function unknownToolResult(name: string): ToolExecResult {
230+ return {
231+ content: [{ type: "text", text: `Unknown tool: ${name}` }],
232+ isError: true,
233+ };
234+}
235+
236+function buildAgentContext(
237+ systemPrompt: string,
238+ messages: Message[],
239+ tools: Tool[],
240+) {
241+ return tools.length > 0
242+ ? { systemPrompt, messages, tools }
243+ : { systemPrompt, messages };
244+}
245+
246+function buildStreamOptions(
247+ apiKey: string | undefined,
248+ effort: ThinkingLevel | undefined,
249+ signal: AbortSignal | undefined,
250+) {
251+ return {
252+ ...(apiKey ? { apiKey } : {}),
253+ ...(effort ? { reasoning: effort } : {}),
254+ ...(signal ? { signal } : {}),
255+ };
256+}
257+
258+async function streamAssistantMessage(
259+ opts: Pick<
260+ RunAgentOpts,
261+ | "model"
262+ | "systemPrompt"
263+ | "tools"
264+ | "messages"
265+ | "apiKey"
266+ | "effort"
267+ | "signal"
268+ | "onEvent"
269+ >,
270+): Promise<AssistantMessage> {
271+ const eventStream = streamSimple(
272+ opts.model,
273+ buildAgentContext(opts.systemPrompt, opts.messages, opts.tools),
274+ buildStreamOptions(opts.apiKey, opts.effort, opts.signal),
275+ );
276+ let assistantMessage: AssistantMessage | undefined;
277+ let partialAssistantMessage: AssistantMessage | undefined;
278+
279+ for await (const event of eventStream) {
280+ if ("partial" in event) {
281+ partialAssistantMessage = event.partial;
282+ }
283+
284+ switch (event.type) {
285+ case "text_delta":
286+ opts.onEvent?.({
287+ type: "text_delta",
288+ delta: event.delta,
289+ content: cloneAssistantContent(event.partial.content),
290+ });
291+ continue;
292+ case "thinking_delta":
293+ opts.onEvent?.({
294+ type: "thinking_delta",
295+ delta: event.delta,
296+ content: cloneAssistantContent(event.partial.content),
297+ });
298+ continue;
299+ case "done":
300+ assistantMessage = event.message;
301+ continue;
302+ case "error":
303+ assistantMessage = event.error;
304+ continue;
305+ case "toolcall_end":
306+ continue;
307+ }
308+ }
309+
310+ const finalAssistantMessage =
311+ assistantMessage ?? (await eventStream.result());
312+ if (!partialAssistantMessage) {
313+ return finalAssistantMessage;
314+ }
315+ return mergeAssistantMessage(partialAssistantMessage, finalAssistantMessage);
316+}
317+
318+function appendAssistantMessage(
319+ db: Database,
320+ sessionId: string,
321+ messages: Message[],
322+ assistantMessage: AssistantMessage,
323+ turn: number,
324+ onEvent: RunAgentOpts["onEvent"],
325+): void {
326+ messages.push(assistantMessage);
327+ appendMessage(db, sessionId, assistantMessage, turn);
328+ onEvent?.({ type: "assistant_message", message: assistantMessage });
329+}
330+
331+function resolveLoopStopReason(
332+ assistantMessage: AssistantMessage,
333+ messages: Message[],
334+ onEvent: RunAgentOpts["onEvent"],
335+): AgentLoopResult | null {
336+ if (
337+ assistantMessage.stopReason === "error" ||
338+ assistantMessage.stopReason === "aborted"
339+ ) {
340+ const eventType =
341+ assistantMessage.stopReason === "error" ? "error" : "aborted";
342+ onEvent?.({ type: eventType, message: assistantMessage });
343+ return { messages, stopReason: assistantMessage.stopReason };
344+ }
345+
346+ if (
347+ assistantMessage.stopReason === "stop" ||
348+ assistantMessage.stopReason === "length"
349+ ) {
350+ onEvent?.({ type: "done", message: assistantMessage });
351+ return { messages, stopReason: assistantMessage.stopReason };
352+ }
353+
354+ return null;
355+}
356+
357+function getAssistantToolCalls(message: AssistantMessage): ToolCall[] {
358+ return message.content.filter((content): content is ToolCall => {
359+ return content.type === "toolCall";
360+ });
361+}
362+
363+async function executeToolCall(
364+ toolCall: ToolCall,
365+ opts: Pick<RunAgentOpts, "toolHandlers" | "cwd" | "signal" | "onEvent">,
366+): Promise<ToolExecResult> {
367+ const handler = opts.toolHandlers.get(toolCall.name);
368+ if (!handler) {
369+ return unknownToolResult(toolCall.name);
370+ }
371+
372+ opts.onEvent?.({
373+ type: "tool_start",
374+ toolCallId: toolCall.id,
375+ name: toolCall.name,
376+ args: toolCall.arguments,
377+ });
378+
379+ let result: ToolExecResult;
380+ try {
381+ result = await handler(
382+ toolCall.arguments,
383+ opts.cwd,
384+ opts.signal,
385+ (partial) => {
386+ opts.onEvent?.({
387+ type: "tool_delta",
388+ toolCallId: toolCall.id,
389+ name: toolCall.name,
390+ result: partial,
391+ });
392+ },
393+ );
394+ } catch (error) {
395+ result = toolErrorResult(toolCall.name, error);
396+ }
397+
398+ opts.onEvent?.({
399+ type: "tool_end",
400+ toolCallId: toolCall.id,
401+ name: toolCall.name,
402+ result,
403+ });
404+ return result;
405+}
406+
407+function appendToolResultMessage(
408+ db: Database,
409+ sessionId: string,
410+ messages: Message[],
411+ toolCall: ToolCall,
412+ result: ToolExecResult,
413+ turn: number,
414+ onEvent: RunAgentOpts["onEvent"],
415+): void {
416+ const toolResultMessage: ToolResultMessage = {
417+ role: "toolResult",
418+ toolCallId: toolCall.id,
419+ toolName: toolCall.name,
420+ content: result.content,
421+ isError: result.isError,
422+ timestamp: Date.now(),
423+ };
424+
425+ messages.push(toolResultMessage);
426+ appendMessage(db, sessionId, toolResultMessage, turn);
427+ onEvent?.({ type: "tool_result", message: toolResultMessage });
428+}
429+
215430 // ---------------------------------------------------------------------------
216431 // Agent loop
217432 // ---------------------------------------------------------------------------
@@ -230,168 +445,49 @@ function toolErrorResult(name: string, error: unknown): ToolExecResult {
230445 export async function runAgentLoop(
231446 opts: RunAgentOpts,
232447 ): Promise<AgentLoopResult> {
233- const {
234- db,
235- sessionId,
236- turn,
237- model,
238- systemPrompt,
239- tools,
240- toolHandlers,
241- messages,
242- cwd,
243- apiKey,
244- effort,
245- signal,
246- onEvent,
247- } = opts;
448+ const { db, sessionId, turn, messages, signal, onEvent, toolHandlers, cwd } =
449+ opts;
248450
249451 while (true) {
250- // Build context for this iteration
251- const context =
252- tools.length > 0
253- ? { systemPrompt, messages, tools }
254- : { systemPrompt, messages };
255-
256- // Stream to LLM
257- const streamOpts = {
258- ...(apiKey ? { apiKey } : {}),
259- ...(effort ? { reasoning: effort } : {}),
260- ...(signal ? { signal } : {}),
261- };
262- const eventStream = streamSimple(model, context, streamOpts);
263- let assistantMessage: AssistantMessage | undefined;
264- let partialAssistantMessage: AssistantMessage | undefined;
265-
266- for await (const event of eventStream) {
267- if ("partial" in event) {
268- partialAssistantMessage = event.partial;
269- }
452+ const assistantMessage = await streamAssistantMessage(opts);
453+ appendAssistantMessage(
454+ db,
455+ sessionId,
456+ messages,
457+ assistantMessage,
458+ turn,
459+ onEvent,
460+ );
270461
271- switch (event.type) {
272- case "text_delta":
273- onEvent?.({
274- type: "text_delta",
275- delta: event.delta,
276- content: cloneAssistantContent(event.partial.content),
277- });
278- break;
279- case "thinking_delta":
280- onEvent?.({
281- type: "thinking_delta",
282- delta: event.delta,
283- content: cloneAssistantContent(event.partial.content),
284- });
285- break;
286- case "toolcall_end":
287- // Tool calls are collected from the final assistant message
288- break;
289- case "done":
290- assistantMessage = event.message;
291- break;
292- case "error":
293- assistantMessage = event.error;
294- break;
295- }
462+ const stopResult = resolveLoopStopReason(
463+ assistantMessage,
464+ messages,
465+ onEvent,
466+ );
467+ if (stopResult) {
468+ return stopResult;
296469 }
297470
298- // If somehow we got no message, fall back to the stream result
299- if (!assistantMessage) {
300- assistantMessage = await eventStream.result();
301- }
302- if (partialAssistantMessage) {
303- assistantMessage = mergeAssistantMessage(
304- partialAssistantMessage,
305- assistantMessage,
471+ for (const toolCall of getAssistantToolCalls(assistantMessage)) {
472+ const result = await executeToolCall(toolCall, {
473+ toolHandlers,
474+ cwd,
475+ signal,
476+ onEvent,
477+ });
478+ appendToolResultMessage(
479+ db,
480+ sessionId,
481+ messages,
482+ toolCall,
483+ result,
484+ turn,
485+ onEvent,
306486 );
307- }
308-
309- // Append assistant message to history and DB
310- messages.push(assistantMessage);
311- appendMessage(db, sessionId, assistantMessage, turn);
312- onEvent?.({ type: "assistant_message", message: assistantMessage });
313-
314- // Handle stop reasons
315- if (
316- assistantMessage.stopReason === "error" ||
317- assistantMessage.stopReason === "aborted"
318- ) {
319- const eventType =
320- assistantMessage.stopReason === "error" ? "error" : "aborted";
321- onEvent?.({ type: eventType, message: assistantMessage });
322- return { messages, stopReason: assistantMessage.stopReason };
323- }
324-
325- if (
326- assistantMessage.stopReason === "stop" ||
327- assistantMessage.stopReason === "length"
328- ) {
329- onEvent?.({ type: "done", message: assistantMessage });
330- return { messages, stopReason: assistantMessage.stopReason };
331- }
332-
333- // stopReason === "toolUse" — execute tool calls and loop
334- const toolCalls = assistantMessage.content.filter(
335- (c): c is ToolCall => c.type === "toolCall",
336- );
337-
338- for (const toolCall of toolCalls) {
339- const handler = toolHandlers.get(toolCall.name);
340-
341- let result: ToolExecResult;
342-
343- if (!handler) {
344- result = {
345- content: [{ type: "text", text: `Unknown tool: ${toolCall.name}` }],
346- isError: true,
347- };
348- } else {
349- onEvent?.({
350- type: "tool_start",
351- toolCallId: toolCall.id,
352- name: toolCall.name,
353- args: toolCall.arguments,
354- });
355-
356- try {
357- result = await handler(toolCall.arguments, cwd, signal, (partial) => {
358- onEvent?.({
359- type: "tool_delta",
360- toolCallId: toolCall.id,
361- name: toolCall.name,
362- result: partial,
363- });
364- });
365- } catch (error) {
366- result = toolErrorResult(toolCall.name, error);
367- }
368-
369- onEvent?.({
370- type: "tool_end",
371- toolCallId: toolCall.id,
372- name: toolCall.name,
373- result,
374- });
375- }
376-
377- const toolResultMessage: ToolResultMessage = {
378- role: "toolResult",
379- toolCallId: toolCall.id,
380- toolName: toolCall.name,
381- content: result.content,
382- isError: result.isError,
383- timestamp: Date.now(),
384- };
385-
386- messages.push(toolResultMessage);
387- appendMessage(db, sessionId, toolResultMessage, turn);
388- onEvent?.({ type: "tool_result", message: toolResultMessage });
389487
390488 if (signal?.aborted) {
391489 return { messages, stopReason: "aborted" };
392490 }
393491 }
394-
395- // Loop back to stream with updated context
396492 }
397493 }