phi-code-agent 0.56.3 → 0.74.0

package/dist/agent-loop.js

@@ -9,20 +9,11 @@ import { EventStream, streamSimple, validateToolArguments, } from "phi-code-ai";
  */
 export function agentLoop(prompts, context, config, signal, streamFn) {
     const stream = createAgentStream();
-    (async () => {
-        const newMessages = [...prompts];
-        const currentContext = {
-            ...context,
-            messages: [...context.messages, ...prompts],
-        };
-        stream.push({ type: "agent_start" });
-        stream.push({ type: "turn_start" });
-        for (const prompt of prompts) {
-            stream.push({ type: "message_start", message: prompt });
-            stream.push({ type: "message_end", message: prompt });
-        }
-        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
-    })();
+    void runAgentLoop(prompts, context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
     return stream;
 }
 /**
@@ -41,33 +32,61 @@ export function agentLoopContinue(context, config, signal, streamFn) {
         throw new Error("Cannot continue from message role: assistant");
     }
     const stream = createAgentStream();
-    (async () => {
-        const newMessages = [];
-        const currentContext = { ...context };
-        stream.push({ type: "agent_start" });
-        stream.push({ type: "turn_start" });
-        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
-    })();
+    void runAgentLoopContinue(context, config, async (event) => {
+        stream.push(event);
+    }, signal, streamFn).then((messages) => {
+        stream.end(messages);
+    });
     return stream;
 }
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn) {
+    const newMessages = [...prompts];
+    const currentContext = {
+        ...context,
+        messages: [...context.messages, ...prompts],
+    };
+    await emit({ type: "agent_start" });
+    await emit({ type: "turn_start" });
+    for (const prompt of prompts) {
+        await emit({ type: "message_start", message: prompt });
+        await emit({ type: "message_end", message: prompt });
+    }
+    await runLoop(currentContext, newMessages, config, signal, emit, streamFn);
+    return newMessages;
+}
+export async function runAgentLoopContinue(context, config, emit, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error("Cannot continue: no messages in context");
+    }
+    if (context.messages[context.messages.length - 1].role === "assistant") {
+        throw new Error("Cannot continue from message role: assistant");
+    }
+    const newMessages = [];
+    const currentContext = { ...context };
+    await emit({ type: "agent_start" });
+    await emit({ type: "turn_start" });
+    await runLoop(currentContext, newMessages, config, signal, emit, streamFn);
+    return newMessages;
+}
 function createAgentStream() {
     return new EventStream((event) => event.type === "agent_end", (event) => (event.type === "agent_end" ? event.messages : []));
 }
 /**
  * Main loop logic shared by agentLoop and agentLoopContinue.
  */
-async function runLoop(currentContext, newMessages, config, signal, stream, streamFn) {
+async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFn) {
+    let currentContext = initialContext;
+    let config = initialConfig;
     let firstTurn = true;
     // Check for steering messages at start (user may have typed while waiting)
     let pendingMessages = (await config.getSteeringMessages?.()) || [];
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
     while (true) {
         let hasMoreToolCalls = true;
-        let steeringAfterTools = null;
         // Inner loop: process tool calls and steering messages
         while (hasMoreToolCalls || pendingMessages.length > 0) {
             if (!firstTurn) {
-                stream.push({ type: "turn_start" });
+                await emit({ type: "turn_start" });
             }
             else {
                 firstTurn = false;
@@ -75,44 +94,64 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
             // Process pending messages (inject before next assistant response)
             if (pendingMessages.length > 0) {
                 for (const message of pendingMessages) {
-                    stream.push({ type: "message_start", message });
-                    stream.push({ type: "message_end", message });
+                    await emit({ type: "message_start", message });
+                    await emit({ type: "message_end", message });
                     currentContext.messages.push(message);
                     newMessages.push(message);
                 }
                 pendingMessages = [];
             }
             // Stream assistant response
-            const message = await streamAssistantResponse(currentContext, config, signal, stream, streamFn);
+            const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFn);
             newMessages.push(message);
             if (message.stopReason === "error" || message.stopReason === "aborted") {
-                stream.push({ type: "turn_end", message, toolResults: [] });
-                stream.push({ type: "agent_end", messages: newMessages });
-                stream.end(newMessages);
+                await emit({ type: "turn_end", message, toolResults: [] });
+                await emit({ type: "agent_end", messages: newMessages });
                 return;
             }
             // Check for tool calls
             const toolCalls = message.content.filter((c) => c.type === "toolCall");
-            hasMoreToolCalls = toolCalls.length > 0;
             const toolResults = [];
-            if (hasMoreToolCalls) {
-                const toolExecution = await executeToolCalls(currentContext.tools, message, signal, stream, config.getSteeringMessages);
-                toolResults.push(...toolExecution.toolResults);
-                steeringAfterTools = toolExecution.steeringMessages ?? null;
+            hasMoreToolCalls = false;
+            if (toolCalls.length > 0) {
+                const executedToolBatch = await executeToolCalls(currentContext, message, config, signal, emit);
+                toolResults.push(...executedToolBatch.messages);
+                hasMoreToolCalls = !executedToolBatch.terminate;
                 for (const result of toolResults) {
                     currentContext.messages.push(result);
                     newMessages.push(result);
                 }
             }
-            stream.push({ type: "turn_end", message, toolResults });
-            // Get steering messages after turn completes
-            if (steeringAfterTools && steeringAfterTools.length > 0) {
-                pendingMessages = steeringAfterTools;
-                steeringAfterTools = null;
+            await emit({ type: "turn_end", message, toolResults });
+            const nextTurnContext = {
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            };
+            const nextTurnSnapshot = await config.prepareNextTurn?.(nextTurnContext);
+            if (nextTurnSnapshot) {
+                currentContext = nextTurnSnapshot.context ?? currentContext;
+                config = {
+                    ...config,
+                    model: nextTurnSnapshot.model ?? config.model,
+                    reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                        ? config.reasoning
+                        : nextTurnSnapshot.thinkingLevel === "off"
+                            ? undefined
+                            : nextTurnSnapshot.thinkingLevel,
+                };
             }
-            else {
-                pendingMessages = (await config.getSteeringMessages?.()) || [];
+            if (await config.shouldStopAfterTurn?.({
+                message,
+                toolResults,
+                context: currentContext,
+                newMessages,
+            })) {
+                await emit({ type: "agent_end", messages: newMessages });
+                return;
             }
+            pendingMessages = (await config.getSteeringMessages?.()) || [];
         }
         // Agent would stop here. Check for follow-up messages.
         const followUpMessages = (await config.getFollowUpMessages?.()) || [];
@@ -124,14 +163,13 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
         // No more messages, exit
         break;
     }
-    stream.push({ type: "agent_end", messages: newMessages });
-    stream.end(newMessages);
+    await emit({ type: "agent_end", messages: newMessages });
 }
 /**
  * Stream an assistant response from the LLM.
  * This is where AgentMessage[] gets transformed to Message[] for the LLM.
  */
-async function streamAssistantResponse(context, config, signal, stream, streamFn) {
+async function streamAssistantResponse(context, config, signal, emit, streamFn) {
     // Apply context transform if configured (AgentMessage[] → AgentMessage[])
     let messages = context.messages;
     if (config.transformContext) {
@@ -161,7 +199,7 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
                 partialMessage = event.partial;
                 context.messages.push(partialMessage);
                 addedPartial = true;
-                stream.push({ type: "message_start", message: { ...partialMessage } });
+                await emit({ type: "message_start", message: { ...partialMessage } });
                 break;
             case "text_start":
             case "text_delta":
@@ -175,7 +213,7 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
                 if (partialMessage) {
                     partialMessage = event.partial;
                     context.messages[context.messages.length - 1] = partialMessage;
-                    stream.push({
+                    await emit({
                         type: "message_update",
                         assistantMessageEvent: event,
                         message: { ...partialMessage },
@@ -192,117 +230,250 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
                     context.messages.push(finalMessage);
                 }
                 if (!addedPartial) {
-                    stream.push({ type: "message_start", message: { ...finalMessage } });
+                    await emit({ type: "message_start", message: { ...finalMessage } });
                 }
-                stream.push({ type: "message_end", message: finalMessage });
+                await emit({ type: "message_end", message: finalMessage });
                 return finalMessage;
             }
         }
     }
-    return await response.result();
+    const finalMessage = await response.result();
+    if (addedPartial) {
+        context.messages[context.messages.length - 1] = finalMessage;
+    }
+    else {
+        context.messages.push(finalMessage);
+        await emit({ type: "message_start", message: { ...finalMessage } });
+    }
+    await emit({ type: "message_end", message: finalMessage });
+    return finalMessage;
 }
 /**
  * Execute tool calls from an assistant message.
  */
-async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages) {
+async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
     const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
-    const results = [];
-    let steeringMessages;
-    for (let index = 0; index < toolCalls.length; index++) {
-        const toolCall = toolCalls[index];
-        const tool = tools?.find((t) => t.name === toolCall.name);
-        stream.push({
+    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode === "sequential");
+    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    }
+    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+}
+async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    const messages = [];
+    for (const toolCall of toolCalls) {
+        await emit({
             type: "tool_execution_start",
             toolCallId: toolCall.id,
             toolName: toolCall.name,
             args: toolCall.arguments,
         });
-        let result;
-        let isError = false;
-        try {
-            if (!tool)
-                throw new Error(`Tool ${toolCall.name} not found`);
-            const validatedArgs = validateToolArguments(tool, toolCall);
-            result = await tool.execute(toolCall.id, validatedArgs, signal, (partialResult) => {
-                stream.push({
-                    type: "tool_execution_update",
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    args: toolCall.arguments,
-                    partialResult,
-                });
-            });
-        }
-        catch (e) {
-            result = {
-                content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }],
-                details: {},
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        let finalized;
+        if (preparation.kind === "immediate") {
+            finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
             };
-            isError = true;
         }
-        stream.push({
-            type: "tool_execution_end",
+        else {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+        }
+        await emitToolExecutionEnd(finalized, emit);
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        finalizedCalls.push(finalized);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(finalizedCalls),
+    };
+}
+async function executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit) {
+    const finalizedCalls = [];
+    for (const toolCall of toolCalls) {
+        await emit({
+            type: "tool_execution_start",
             toolCallId: toolCall.id,
             toolName: toolCall.name,
-            result,
-            isError,
+            args: toolCall.arguments,
         });
-        const toolResultMessage = {
-            role: "toolResult",
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            content: result.content,
-            details: result.details,
-            isError,
-            timestamp: Date.now(),
+        const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+        if (preparation.kind === "immediate") {
+            const finalized = {
+                toolCall,
+                result: preparation.result,
+                isError: preparation.isError,
+            };
+            await emitToolExecutionEnd(finalized, emit);
+            finalizedCalls.push(finalized);
+            continue;
+        }
+        finalizedCalls.push(async () => {
+            const executed = await executePreparedToolCall(preparation, signal, emit);
+            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            await emitToolExecutionEnd(finalized, emit);
+            return finalized;
+        });
+    }
+    const orderedFinalizedCalls = await Promise.all(finalizedCalls.map((entry) => (typeof entry === "function" ? entry() : Promise.resolve(entry))));
+    const messages = [];
+    for (const finalized of orderedFinalizedCalls) {
+        const toolResultMessage = createToolResultMessage(finalized);
+        await emitToolResultMessage(toolResultMessage, emit);
+        messages.push(toolResultMessage);
+    }
+    return {
+        messages,
+        terminate: shouldTerminateToolBatch(orderedFinalizedCalls),
+    };
+}
+function shouldTerminateToolBatch(finalizedCalls) {
+    return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
+}
+function prepareToolCallArguments(tool, toolCall) {
+    if (!tool.prepareArguments) {
+        return toolCall;
+    }
+    const preparedArguments = tool.prepareArguments(toolCall.arguments);
+    if (preparedArguments === toolCall.arguments) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        arguments: preparedArguments,
+    };
+}
+async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+    if (!tool) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(`Tool ${toolCall.name} not found`),
+            isError: true,
         };
-        results.push(toolResultMessage);
-        stream.push({ type: "message_start", message: toolResultMessage });
-        stream.push({ type: "message_end", message: toolResultMessage });
-        // Check for steering messages - skip remaining tools if user interrupted
-        if (getSteeringMessages) {
-            const steering = await getSteeringMessages();
-            if (steering.length > 0) {
-                steeringMessages = steering;
-                const remainingCalls = toolCalls.slice(index + 1);
-                for (const skipped of remainingCalls) {
-                    results.push(skipToolCall(skipped, stream));
-                }
-                break;
+    }
+    try {
+        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
+        const validatedArgs = validateToolArguments(tool, preparedToolCall);
+        if (config.beforeToolCall) {
+            const beforeResult = await config.beforeToolCall({
+                assistantMessage,
+                toolCall,
+                args: validatedArgs,
+                context: currentContext,
+            }, signal);
+            if (beforeResult?.block) {
+                return {
+                    kind: "immediate",
+                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
+                    isError: true,
+                };
             }
         }
+        return {
+            kind: "prepared",
+            toolCall,
+            tool,
+            args: validatedArgs,
+        };
+    }
+    catch (error) {
+        return {
+            kind: "immediate",
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
     }
-    return { toolResults: results, steeringMessages };
 }
-function skipToolCall(toolCall, stream) {
-    const result = {
-        content: [{ type: "text", text: "Skipped due to queued user message." }],
+async function executePreparedToolCall(prepared, signal, emit) {
+    const updateEvents = [];
+    try {
+        const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
+            updateEvents.push(Promise.resolve(emit({
+                type: "tool_execution_update",
+                toolCallId: prepared.toolCall.id,
+                toolName: prepared.toolCall.name,
+                args: prepared.toolCall.arguments,
+                partialResult,
+            })));
+        });
+        await Promise.all(updateEvents);
+        return { result, isError: false };
+    }
+    catch (error) {
+        await Promise.all(updateEvents);
+        return {
+            result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+            isError: true,
+        };
+    }
+}
+async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
+    let result = executed.result;
+    let isError = executed.isError;
+    if (config.afterToolCall) {
+        try {
+            const afterResult = await config.afterToolCall({
+                assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                result,
+                isError,
+                context: currentContext,
+            }, signal);
+            if (afterResult) {
+                result = {
+                    content: afterResult.content ?? result.content,
+                    details: afterResult.details ?? result.details,
+                    terminate: afterResult.terminate ?? result.terminate,
+                };
+                isError = afterResult.isError ?? isError;
+            }
+        }
+        catch (error) {
+            result = createErrorToolResult(error instanceof Error ? error.message : String(error));
+            isError = true;
+        }
+    }
+    return {
+        toolCall: prepared.toolCall,
+        result,
+        isError,
+    };
+}
+function createErrorToolResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
         details: {},
     };
-    stream.push({
-        type: "tool_execution_start",
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        args: toolCall.arguments,
-    });
-    stream.push({
+}
+async function emitToolExecutionEnd(finalized, emit) {
+    await emit({
         type: "tool_execution_end",
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        result,
-        isError: true,
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: finalized.isError,
     });
-    const toolResultMessage = {
+}
+function createToolResultMessage(finalized) {
+    return {
         role: "toolResult",
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        content: result.content,
-        details: {},
-        isError: true,
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        content: finalized.result.content,
+        details: finalized.result.details,
+        isError: finalized.isError,
         timestamp: Date.now(),
     };
-    stream.push({ type: "message_start", message: toolResultMessage });
-    stream.push({ type: "message_end", message: toolResultMessage });
-    return toolResultMessage;
+}
+async function emitToolResultMessage(toolResultMessage, emit) {
+    await emit({ type: "message_start", message: toolResultMessage });
+    await emit({ type: "message_end", message: toolResultMessage });
 }
 //# sourceMappingURL=agent-loop.js.map