@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/agents/local-executor.js

@@ -6,8 +6,8 @@
 import { reportError } from '../utils/errorReporting.js';
 import { GeminiChat, StreamEventType } from '../core/geminiChat.js';
 import { Type } from '@google/genai';
-import { executeToolCall } from '../core/nonInteractiveToolExecutor.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
+import { DiscoveredMCPTool, MCP_QUALIFIED_NAME_SEPARATOR, } from '../tools/mcp-tool.js';
 import { CompressionStatus } from '../core/turn.js';
 import {} from '../scheduler/types.js';
 import { ChatCompressionService } from '../services/chatCompressionService.js';
@@ -15,17 +15,24 @@ import { getDirectoryContextString } from '../utils/environmentContext.js';
 import { promptIdContext } from '../utils/promptIdContext.js';
 import { logAgentStart, logAgentFinish, logRecoveryAttempt, } from '../telemetry/loggers.js';
 import { AgentStartEvent, AgentFinishEvent, RecoveryAttemptEvent, } from '../telemetry/types.js';
-import { AgentTerminateMode } from './types.js';
+import { AgentTerminateMode, DEFAULT_QUERY_STRING, DEFAULT_MAX_TURNS, DEFAULT_MAX_TIME_MINUTES, } from './types.js';
 import { templateString } from './utils.js';
+import { DEFAULT_GEMINI_MODEL, isAutoModel } from '../config/models.js';
 import { parseThought } from '../utils/thoughtUtils.js';
 import {} from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { debugLogger } from '../utils/debugLogger.js';
 import { getModelConfigAlias } from './registry.js';
 import { getVersion } from '../utils/version.js';
-import { ApprovalMode } from '../policy/types.js';
+import { getToolCallContext } from '../utils/toolCallContext.js';
+import { scheduleAgentTools } from './agent-scheduler.js';
+import { DeadlineTimer } from '../utils/deadlineTimer.js';
+import { LlmRole } from '../telemetry/types.js';
 const TASK_COMPLETE_TOOL_NAME = 'complete_task';
 const GRACE_PERIOD_MS = 60 * 1000; // 1 min
+export function createUnauthorizedToolError(toolName) {
+    return `Unauthorized tool call: '${toolName}' is not available to this agent.`;
+}
 /**
  * Executes an agent loop based on an {@link AgentDefinition}.
  *
@@ -39,6 +46,7 @@ export class LocalAgentExecutor {
     runtimeContext;
     onActivity;
     compressionService;
+    parentCallId;
     hasFailedCompressionAttempt = false;
     /**
      * Creates and validates a new `AgentExecutor` instance.
@@ -55,15 +63,29 @@ export class LocalAgentExecutor {
         // Create an isolated tool registry for this agent instance.
         const agentToolRegistry = new ToolRegistry(runtimeContext, runtimeContext.getMessageBus());
         const parentToolRegistry = runtimeContext.getToolRegistry();
+        const allAgentNames = new Set(runtimeContext.getAgentRegistry().getAllAgentNames());
+        const registerToolByName = (toolName) => {
+            // Check if the tool is a subagent to prevent recursion.
+            // We do not allow agents to call other agents.
+            if (allAgentNames.has(toolName)) {
+                debugLogger.warn(`[LocalAgentExecutor] Skipping subagent tool '${toolName}' for agent '${definition.name}' to prevent recursion.`);
+                return;
+            }
+            // If the tool is referenced by name, retrieve it from the parent
+            // registry and register it with the agent's isolated registry.
+            const tool = parentToolRegistry.getTool(toolName);
+            if (tool) {
+                if (tool instanceof DiscoveredMCPTool &&
+                    !toolName.includes(MCP_QUALIFIED_NAME_SEPARATOR)) {
+                    throw new Error(`MCP tool '${toolName}' must be requested with its server prefix (e.g., '${tool.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${toolName}') in agent '${definition.name}'.`);
+                }
+                agentToolRegistry.registerTool(tool);
+            }
+        };
         if (definition.toolConfig) {
             for (const toolRef of definition.toolConfig.tools) {
                 if (typeof toolRef === 'string') {
-                    // If the tool is referenced by name, retrieve it from the parent
-                    // registry and register it with the agent's isolated registry.
-                    const toolFromParent = parentToolRegistry.getTool(toolRef);
-                    if (toolFromParent) {
-                        agentToolRegistry.registerTool(toolFromParent);
-                    }
+                    registerToolByName(toolRef);
                 }
                 else if (typeof toolRef === 'object' &&
                     'name' in toolRef &&
@@ -73,11 +95,20 @@ export class LocalAgentExecutor {
                 // Note: Raw `FunctionDeclaration` objects in the config don't need to be
                 // registered; their schemas are passed directly to the model later.
             }
-            agentToolRegistry.sortTools();
         }
+        else {
+            // If no tools are explicitly configured, default to all available tools.
+            for (const toolName of parentToolRegistry.getAllToolNames()) {
+                registerToolByName(toolName);
+            }
+        }
+        agentToolRegistry.sortTools();
         // Get the parent prompt ID from context
         const parentPromptId = promptIdContext.getStore();
-        return new LocalAgentExecutor(definition, runtimeContext, agentToolRegistry, parentPromptId, onActivity);
+        // Get the parent tool call ID from context
+        const toolContext = getToolCallContext();
+        const parentCallId = toolContext?.callId;
+        return new LocalAgentExecutor(definition, runtimeContext, agentToolRegistry, parentPromptId, parentCallId, onActivity);
     }
     /**
      * Constructs a new AgentExecutor instance.
@@ -85,12 +116,13 @@ export class LocalAgentExecutor {
      * @private This constructor is private. Use the static `create` method to
      * instantiate the class.
      */
-    constructor(definition, runtimeContext, toolRegistry, parentPromptId, onActivity) {
+    constructor(definition, runtimeContext, toolRegistry, parentPromptId, parentCallId, onActivity) {
         this.definition = definition;
         this.runtimeContext = runtimeContext;
         this.toolRegistry = toolRegistry;
         this.onActivity = onActivity;
         this.compressionService = new ChatCompressionService();
+        this.parentCallId = parentCallId;
         const randomIdPart = Math.random().toString(36).slice(2, 8);
         // parentPromptId will be undefined if this agent is invoked directly
         // (top-level), rather than as a sub-agent.
@@ -104,7 +136,8 @@ export class LocalAgentExecutor {
      * @returns An {@link AgentTurnResult} object indicating whether to continue
      * or stop the agent loop.
      */
-    async executeTurn(chat, currentMessage, turnCounter, combinedSignal, timeoutSignal) {
+    async executeTurn(chat, currentMessage, turnCounter, combinedSignal, timeoutSignal, // Pass the timeout controller's signal
+    onWaitingForConfirmation) {
         const promptId = `${this.agentId}#${turnCounter}`;
         await this.tryCompressChat(chat, promptId);
         const { functionCalls } = await promptIdContext.run(promptId, async () => this.callModel(chat, currentMessage, combinedSignal, promptId));
@@ -130,7 +163,7 @@ export class LocalAgentExecutor {
                 finalResult: null,
             };
         }
-        const { nextMessage, submittedOutput, taskCompleted } = await this.processFunctionCalls(functionCalls, combinedSignal, promptId);
+        const { nextMessage, submittedOutput, taskCompleted } = await this.processFunctionCalls(functionCalls, combinedSignal, promptId, onWaitingForConfirmation);
         if (taskCompleted) {
             const finalResult = submittedOutput ?? 'Task completed successfully.';
             return {
@@ -171,7 +204,8 @@ export class LocalAgentExecutor {
      *
      * @returns The final result string if recovery was successful, or `null` if it failed.
      */
-    async executeFinalWarningTurn(chat, turnCounter, reason, externalSignal) {
+    async executeFinalWarningTurn(chat, turnCounter, reason, externalSignal, // The original signal passed to run()
+    onWaitingForConfirmation) {
         this.emitActivity('THOUGHT_CHUNK', {
             text: `Execution limit reached (${reason}). Attempting one final recovery turn with a grace period.`,
         });
@@ -191,7 +225,8 @@ export class LocalAgentExecutor {
                 graceTimeoutController.signal,
             ]);
             const turnResult = await this.executeTurn(chat, recoveryMessage, turnCounter, // This will be the "last" turn number
-            combinedSignal, graceTimeoutController.signal);
+            combinedSignal, graceTimeoutController.signal, // Pass grace signal to identify a *grace* timeout
+            onWaitingForConfirmation);
             if (turnResult.status === 'stop' &&
                 turnResult.terminateReason === AgentTerminateMode.GOAL) {
                 // Success!
@@ -233,11 +268,20 @@ export class LocalAgentExecutor {
         let turnCounter = 0;
         let terminateReason = AgentTerminateMode.ERROR;
         let finalResult = null;
-        const { max_time_minutes } = this.definition.runConfig;
-        const timeoutController = new AbortController();
-        const timeoutId = setTimeout(() => timeoutController.abort(new Error('Agent timed out.')), max_time_minutes * 60 * 1000);
+        const maxTimeMinutes = this.definition.runConfig.maxTimeMinutes ?? DEFAULT_MAX_TIME_MINUTES;
+        const maxTurns = this.definition.runConfig.maxTurns ?? DEFAULT_MAX_TURNS;
+        const deadlineTimer = new DeadlineTimer(maxTimeMinutes * 60 * 1000, 'Agent timed out.');
+        // Track time spent waiting for user confirmation to credit it back to the agent.
+        const onWaitingForConfirmation = (waiting) => {
+            if (waiting) {
+                deadlineTimer.pause();
+            }
+            else {
+                deadlineTimer.resume();
+            }
+        };
         // Combine the external signal with the internal timeout signal.
-        const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
+        const combinedSignal = AbortSignal.any([signal, deadlineTimer.signal]);
         logAgentStart(this.runtimeContext, new AgentStartEvent(this.agentId, this.definition.name));
         let chat;
         let tools;
@@ -253,11 +297,11 @@ export class LocalAgentExecutor {
             chat = await this.createChatObject(augmentedInputs, tools);
             const query = this.definition.promptConfig.query
                 ? templateString(this.definition.promptConfig.query, augmentedInputs)
-                : 'Get Started!';
+                : DEFAULT_QUERY_STRING;
             let currentMessage = { role: 'user', parts: [{ text: query }] };
             while (true) {
                 // Check for termination conditions like max turns.
-                const reason = this.checkTermination(startTime, turnCounter);
+                const reason = this.checkTermination(turnCounter, maxTurns);
                 if (reason) {
                     terminateReason = reason;
                     break;
@@ -265,12 +309,12 @@ export class LocalAgentExecutor {
                 // Check for timeout or external abort.
                 if (combinedSignal.aborted) {
                     // Determine which signal caused the abort.
-                    terminateReason = timeoutController.signal.aborted
+                    terminateReason = deadlineTimer.signal.aborted
                         ? AgentTerminateMode.TIMEOUT
                         : AgentTerminateMode.ABORTED;
                     break;
                 }
-                const turnResult = await this.executeTurn(chat, currentMessage, turnCounter++, combinedSignal, timeoutController.signal);
+                const turnResult = await this.executeTurn(chat, currentMessage, turnCounter++, combinedSignal, deadlineTimer.signal, onWaitingForConfirmation);
                 if (turnResult.status === 'stop') {
                     terminateReason = turnResult.terminateReason;
                     // Only set finalResult if the turn provided one (e.g., error or goal).
@@ -289,7 +333,8 @@ export class LocalAgentExecutor {
                 terminateReason !== AgentTerminateMode.ABORTED &&
                 terminateReason !== AgentTerminateMode.GOAL) {
                 const recoveryResult = await this.executeFinalWarningTurn(chat, turnCounter, // Use current turnCounter for the recovery attempt
-                terminateReason, signal);
+                terminateReason, signal, // Pass the external signal
+                onWaitingForConfirmation);
                 if (recoveryResult !== null) {
                     // Recovery Succeeded
                     terminateReason = AgentTerminateMode.GOAL;
@@ -298,14 +343,14 @@ export class LocalAgentExecutor {
                 else {
                     // Recovery Failed. Set the final error message based on the *original* reason.
                     if (terminateReason === AgentTerminateMode.TIMEOUT) {
-                        finalResult = `Agent timed out after ${this.definition.runConfig.max_time_minutes} minutes.`;
+                        finalResult = `Agent timed out after ${maxTimeMinutes} minutes.`;
                         this.emitActivity('ERROR', {
                             error: finalResult,
                             context: 'timeout',
                         });
                     }
                     else if (terminateReason === AgentTerminateMode.MAX_TURNS) {
-                        finalResult = `Agent reached max turns limit (${this.definition.runConfig.max_turns}).`;
+                        finalResult = `Agent reached max turns limit (${maxTurns}).`;
                         this.emitActivity('ERROR', {
                             error: finalResult,
                             context: 'max_turns',
@@ -339,14 +384,14 @@ export class LocalAgentExecutor {
             // Check if the error is an AbortError caused by our internal timeout.
             if (error instanceof Error &&
                 error.name === 'AbortError' &&
-                timeoutController.signal.aborted &&
+                deadlineTimer.signal.aborted &&
                 !signal.aborted // Ensure the external signal was not the cause
             ) {
                 terminateReason = AgentTerminateMode.TIMEOUT;
                 // Also use the unified recovery logic here
                 if (chat && tools) {
                     const recoveryResult = await this.executeFinalWarningTurn(chat, turnCounter, // Use current turnCounter
-                    AgentTerminateMode.TIMEOUT, signal);
+                    AgentTerminateMode.TIMEOUT, signal, onWaitingForConfirmation);
                     if (recoveryResult !== null) {
                         // Recovery Succeeded
                         terminateReason = AgentTerminateMode.GOAL;
@@ -358,7 +403,7 @@ export class LocalAgentExecutor {
                     }
                 }
                 // Recovery failed or wasn't possible
-                finalResult = `Agent timed out after ${this.definition.runConfig.max_time_minutes} minutes.`;
+                finalResult = `Agent timed out after ${maxTimeMinutes} minutes.`;
                 this.emitActivity('ERROR', {
                     error: finalResult,
                     context: 'timeout',
@@ -372,12 +417,12 @@ export class LocalAgentExecutor {
             throw error; // Re-throw other errors or external aborts.
         }
         finally {
-            clearTimeout(timeoutId);
+            deadlineTimer.abort();
             logAgentFinish(this.runtimeContext, new AgentFinishEvent(this.agentId, this.definition.name, Date.now() - startTime, turnCounter, terminateReason));
         }
     }
     async tryCompressChat(chat, prompt_id) {
-        const model = this.definition.modelConfig.model;
+        const model = this.definition.modelConfig.model ?? DEFAULT_GEMINI_MODEL;
         const { newHistory, info } = await this.compressionService.compress(chat, prompt_id, false, model, this.runtimeContext, this.hasFailedCompressionAttempt);
         if (info.compressionStatus ===
             CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT) {
@@ -396,10 +441,44 @@ export class LocalAgentExecutor {
      * @returns The model's response, including any tool calls or text.
      */
     async callModel(chat, message, signal, promptId) {
+        const modelConfigAlias = getModelConfigAlias(this.definition);
+        // Resolve the model config early to get the concrete model string (which may be `auto`).
+        const resolvedConfig = this.runtimeContext.modelConfigService.getResolvedConfig({
+            model: modelConfigAlias,
+            overrideScope: this.definition.name,
+        });
+        const requestedModel = resolvedConfig.model;
+        let modelToUse;
+        if (isAutoModel(requestedModel)) {
+            // TODO(joshualitt): This try / catch is inconsistent with the routing
+            // behavior for the main agent. Ideally, we would have a universal
+            // policy for routing failure. Given routing failure does not necessarily
+            // mean generation will fail, we may want to share this logic with
+            // other places we use model routing.
+            try {
+                const routingContext = {
+                    history: chat.getHistory(/*curated=*/ true),
+                    request: message.parts || [],
+                    signal,
+                    requestedModel,
+                };
+                const router = this.runtimeContext.getModelRouterService();
+                const decision = await router.route(routingContext);
+                modelToUse = decision.model;
+            }
+            catch (error) {
+                debugLogger.warn(`Error during model routing: ${error}`);
+                modelToUse = DEFAULT_GEMINI_MODEL;
+            }
+        }
+        else {
+            modelToUse = requestedModel;
+        }
+        const role = LlmRole.SUBAGENT;
         const responseStream = await chat.sendMessageStream({
-            model: getModelConfigAlias(this.definition),
+            model: modelToUse,
             overrideScope: this.definition.name,
-        }, message.parts || [], promptId, signal);
+        }, message.parts || [], promptId, signal, role);
         const functionCalls = [];
         let textResponse = '';
         for await (const resp of responseStream) {
@@ -454,28 +533,31 @@ export class LocalAgentExecutor {
      *
      * @returns A new `Content` object for history, any submitted output, and completion status.
      */
-    async processFunctionCalls(functionCalls, signal, promptId) {
+    async processFunctionCalls(functionCalls, signal, promptId, onWaitingForConfirmation) {
         const allowedToolNames = new Set(this.toolRegistry.getAllToolNames());
         // Always allow the completion tool
         allowedToolNames.add(TASK_COMPLETE_TOOL_NAME);
         let submittedOutput = null;
         let taskCompleted = false;
-        // We'll collect promises for the tool executions
-        const toolExecutionPromises = [];
-        // And we'll need a place to store the synchronous results (like complete_task or blocked calls)
-        const syncResponseParts = [];
+        // We'll separate complete_task from other tools
+        const toolRequests = [];
+        // Map to keep track of tool name by callId for activity emission
+        const toolNameMap = new Map();
+        // Synchronous results (like complete_task or unauthorized calls)
+        const syncResults = new Map();
         for (const [index, functionCall] of functionCalls.entries()) {
             const callId = functionCall.id ?? `${promptId}-${index}`;
             const args = functionCall.args ?? {};
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            const toolName = functionCall.name;
             this.emitActivity('TOOL_CALL_START', {
-                name: functionCall.name,
+                name: toolName,
                 args,
             });
-            if (functionCall.name === TASK_COMPLETE_TOOL_NAME) {
+            if (toolName === TASK_COMPLETE_TOOL_NAME) {
                 if (taskCompleted) {
-                    // We already have a completion from this turn. Ignore subsequent ones.
                     const error = 'Task already marked complete in this turn. Ignoring duplicate call.';
-                    syncResponseParts.push({
+                    syncResults.set(callId, {
                         functionResponse: {
                             name: TASK_COMPLETE_TOOL_NAME,
                             response: { error },
@@ -484,7 +566,7 @@ export class LocalAgentExecutor {
                     });
                     this.emitActivity('ERROR', {
                         context: 'tool_call',
-                        name: functionCall.name,
+                        name: toolName,
                         error,
                     });
                     continue;
@@ -499,7 +581,7 @@ export class LocalAgentExecutor {
                         if (!validationResult.success) {
                             taskCompleted = false; // Validation failed, revoke completion
                             const error = `Output validation failed: ${JSON.stringify(validationResult.error.flatten())}`;
-                            syncResponseParts.push({
+                            syncResults.set(callId, {
                                 functionResponse: {
                                     name: TASK_COMPLETE_TOOL_NAME,
                                     response: { error },
@@ -508,7 +590,7 @@ export class LocalAgentExecutor {
                             });
                             this.emitActivity('ERROR', {
                                 context: 'tool_call',
-                                name: functionCall.name,
+                                name: toolName,
                                 error,
                             });
                             continue;
@@ -523,7 +605,7 @@ export class LocalAgentExecutor {
                                     ? outputValue
                                     : JSON.stringify(outputValue, null, 2);
                         }
-                        syncResponseParts.push({
+                        syncResults.set(callId, {
                             functionResponse: {
                                 name: TASK_COMPLETE_TOOL_NAME,
                                 response: { result: 'Output submitted and task completed.' },
@@ -531,7 +613,7 @@ export class LocalAgentExecutor {
                             },
                         });
                         this.emitActivity('TOOL_CALL_END', {
-                            name: functionCall.name,
+                            name: toolName,
                             output: 'Output submitted and task completed.',
                         });
                     }
@@ -539,7 +621,7 @@ export class LocalAgentExecutor {
                         // Failed to provide required output.
                         taskCompleted = false; // Revoke completion status
                         const error = `Missing required argument '${outputName}' for completion.`;
-                        syncResponseParts.push({
+                        syncResults.set(callId, {
                             functionResponse: {
                                 name: TASK_COMPLETE_TOOL_NAME,
                                 response: { error },
@@ -548,7 +630,7 @@ export class LocalAgentExecutor {
                         });
                         this.emitActivity('ERROR', {
                             context: 'tool_call',
-                            name: functionCall.name,
+                            name: toolName,
                             error,
                         });
                     }
@@ -563,7 +645,7 @@ export class LocalAgentExecutor {
                             typeof resultArg === 'string'
                                 ? resultArg
                                 : JSON.stringify(resultArg, null, 2);
-                        syncResponseParts.push({
+                        syncResults.set(callId, {
                             functionResponse: {
                                 name: TASK_COMPLETE_TOOL_NAME,
                                 response: { status: 'Result submitted and task completed.' },
@@ -571,7 +653,7 @@ export class LocalAgentExecutor {
                             },
                         });
                         this.emitActivity('TOOL_CALL_END', {
-                            name: functionCall.name,
+                            name: toolName,
                             output: 'Result submitted and task completed.',
                         });
                     }
@@ -579,7 +661,7 @@ export class LocalAgentExecutor {
                         // No result provided - this is an error for agents expected to return results
                         taskCompleted = false; // Revoke completion
                         const error = 'Missing required "result" argument. You must provide your findings when calling complete_task.';
-                        syncResponseParts.push({
+                        syncResults.set(callId, {
                             functionResponse: {
                                 name: TASK_COMPLETE_TOOL_NAME,
                                 response: { error },
@@ -588,7 +670,7 @@ export class LocalAgentExecutor {
                         });
                         this.emitActivity('ERROR', {
                             context: 'tool_call',
-                            name: functionCall.name,
+                            name: toolName,
                             error,
                         });
                     }
@@ -596,61 +678,75 @@ export class LocalAgentExecutor {
                 continue;
             }
             // Handle standard tools
-            if (!allowedToolNames.has(functionCall.name)) {
-                const error = `Unauthorized tool call: '${functionCall.name}' is not available to this agent.`;
+            if (!allowedToolNames.has(toolName)) {
+                const error = createUnauthorizedToolError(toolName);
                 debugLogger.warn(`[LocalAgentExecutor] Blocked call: ${error}`);
-                syncResponseParts.push({
+                syncResults.set(callId, {
                     functionResponse: {
-                        name: functionCall.name,
+                        name: toolName,
                         id: callId,
                         response: { error },
                     },
                 });
                 this.emitActivity('ERROR', {
                     context: 'tool_call_unauthorized',
-                    name: functionCall.name,
+                    name: toolName,
                     callId,
                     error,
                 });
                 continue;
             }
-            const requestInfo = {
+            toolRequests.push({
                 callId,
-                name: functionCall.name,
+                name: toolName,
                 args,
-                isClientInitiated: true,
+                isClientInitiated: false, // These are coming from the subagent (the "model")
                 prompt_id: promptId,
-            };
-            // Create a promise for the tool execution
-            const executionPromise = (async () => {
-                const agentContext = Object.create(this.runtimeContext);
-                agentContext.getToolRegistry = () => this.toolRegistry;
-                agentContext.getApprovalMode = () => ApprovalMode.YOLO;
-                const { response: toolResponse } = await executeToolCall(agentContext, requestInfo, signal);
-                if (toolResponse.error) {
+            });
+            toolNameMap.set(callId, toolName);
+        }
+        // Execute standard tool calls using the new scheduler
+        if (toolRequests.length > 0) {
+            const completedCalls = await scheduleAgentTools(this.runtimeContext, toolRequests, {
+                schedulerId: this.agentId,
+                parentCallId: this.parentCallId,
+                toolRegistry: this.toolRegistry,
+                signal,
+                onWaitingForConfirmation,
+            });
+            for (const call of completedCalls) {
+                const toolName = toolNameMap.get(call.request.callId) || call.request.name;
+                if (call.status === 'success') {
+                    this.emitActivity('TOOL_CALL_END', {
+                        name: toolName,
+                        output: call.response.resultDisplay,
+                    });
+                }
+                else if (call.status === 'error') {
                     this.emitActivity('ERROR', {
                         context: 'tool_call',
-                        name: functionCall.name,
-                        error: toolResponse.error.message,
+                        name: toolName,
+                        error: call.response.error?.message || 'Unknown error',
                     });
                 }
-                else {
-                    this.emitActivity('TOOL_CALL_END', {
-                        name: functionCall.name,
-                        output: toolResponse.resultDisplay,
+                else if (call.status === 'cancelled') {
+                    this.emitActivity('ERROR', {
+                        context: 'tool_call',
+                        name: toolName,
+                        error: 'Tool call was cancelled.',
                     });
                 }
-                return toolResponse.responseParts;
-            })();
-            toolExecutionPromises.push(executionPromise);
-        }
-        // Wait for all tool executions to complete
-        const asyncResults = await Promise.all(toolExecutionPromises);
-        // Combine all response parts
-        const toolResponseParts = [...syncResponseParts];
-        for (const result of asyncResults) {
-            if (result) {
-                toolResponseParts.push(...result);
+                // Add result to syncResults to preserve order later
+                syncResults.set(call.request.callId, call.response.responseParts[0]);
+            }
+        }
+        // Reconstruct toolResponseParts in the original order
+        const toolResponseParts = [];
+        for (const [index, functionCall] of functionCalls.entries()) {
+            const callId = functionCall.id ?? `${promptId}-${index}`;
+            const part = syncResults.get(callId);
+            if (part) {
+                toolResponseParts.push(part);
             }
         }
         // If all authorized tool calls failed (and task isn't complete), provide a generic error.
@@ -708,6 +804,7 @@ export class LocalAgentExecutor {
             const jsonSchema = zodToJsonSchema(outputConfig.schema);
             const { $schema: _$schema, definitions: _definitions, ...schema } = jsonSchema;
             completeTool.parameters.properties[outputConfig.outputName] =
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 schema;
             completeTool.parameters.required.push(outputConfig.outputName);
         }
@@ -778,9 +875,8 @@ Important Rules:
      *
      * @returns The reason for termination, or `null` if execution can continue.
      */
-    checkTermination(startTime, turnCounter) {
-        const { runConfig } = this.definition;
-        if (runConfig.max_turns && turnCounter >= runConfig.max_turns) {
+    checkTermination(turnCounter, maxTurns) {
+        if (turnCounter >= maxTurns) {
             return AgentTerminateMode.MAX_TURNS;
         }
         return null;