@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/core/coreToolScheduler.js

@@ -4,20 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ToolConfirmationOutcome, } from '../tools/tools.js';
-import { ApprovalMode } from '../policy/types.js';
+import { PolicyDecision } from '../policy/types.js';
 import { logToolCall } from '../telemetry/loggers.js';
 import { ToolErrorType } from '../tools/tool-error.js';
 import { ToolCallEvent } from '../telemetry/types.js';
 import { runInDevTraceSpan } from '../telemetry/trace.js';
-import { isModifiableDeclarativeTool, modifyWithEditor, } from '../tools/modifiable-tool.js';
-import * as Diff from 'diff';
-import { SHELL_TOOL_NAMES } from '../utils/shell-utils.js';
-import { doesToolInvocationMatch, getToolSuggestion, } from '../utils/tool-utils.js';
-import { isShellInvocationAllowlisted } from '../utils/shell-permissions.js';
+import { ToolModificationHandler } from '../scheduler/tool-modifier.js';
+import { getToolSuggestion } from '../utils/tool-utils.js';
 import { MessageBusType } from '../confirmation-bus/types.js';
-import { fireToolNotificationHook } from './coreToolHookTriggers.js';
 import {} from '../scheduler/types.js';
+import { CoreToolCallStatus } from '../scheduler/types.js';
 import { ToolExecutor } from '../scheduler/tool-executor.js';
+import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
+import { getPolicyDenialError } from '../scheduler/policy.js';
 const createErrorResponse = (request, error, errorType) => ({
     callId: request.callId,
     error,
@@ -51,6 +50,7 @@ export class CoreToolScheduler {
     toolCallQueue = [];
     completedToolCallsForBatch = [];
     toolExecutor;
+    toolModifier;
     constructor(options) {
         this.config = options.config;
         this.outputUpdateHandler = options.outputUpdateHandler;
@@ -58,6 +58,7 @@ export class CoreToolScheduler {
         this.onToolCallsUpdate = options.onToolCallsUpdate;
         this.getPreferredEditor = options.getPreferredEditor;
         this.toolExecutor = new ToolExecutor(this.config);
+        this.toolModifier = new ToolModificationHandler();
         // Subscribe to message bus for ASK_USER policy decisions
         // Use a static WeakMap to ensure we only subscribe ONCE per MessageBus instance
         // This prevents memory leaks when multiple CoreToolScheduler instances are created
@@ -85,9 +86,9 @@ export class CoreToolScheduler {
     setStatusInternal(targetCallId, newStatus, signal, auxiliaryData) {
         this.toolCalls = this.toolCalls.map((currentCall) => {
             if (currentCall.request.callId !== targetCallId ||
-                currentCall.status === 'success' ||
-                currentCall.status === 'error' ||
-                currentCall.status === 'cancelled') {
+                currentCall.status === CoreToolCallStatus.Success ||
+                currentCall.status === CoreToolCallStatus.Error ||
+                currentCall.status === CoreToolCallStatus.Cancelled) {
                 return currentCall;
             }
             // currentCall is a non-terminal state here and should have startTime and tool.
@@ -95,8 +96,9 @@ export class CoreToolScheduler {
             const toolInstance = currentCall.tool;
             const invocation = currentCall.invocation;
             const outcome = currentCall.outcome;
+            const approvalMode = currentCall.approvalMode;
             switch (newStatus) {
-                case 'success': {
+                case CoreToolCallStatus.Success: {
                     const durationMs = existingStartTime
                         ? Date.now() - existingStartTime
                         : undefined;
@@ -104,51 +106,59 @@ export class CoreToolScheduler {
                         request: currentCall.request,
                         tool: toolInstance,
                         invocation,
-                        status: 'success',
+                        status: CoreToolCallStatus.Success,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                         response: auxiliaryData,
                         durationMs,
                         outcome,
+                        approvalMode,
                     };
                 }
-                case 'error': {
+                case CoreToolCallStatus.Error: {
                     const durationMs = existingStartTime
                         ? Date.now() - existingStartTime
                         : undefined;
                     return {
                         request: currentCall.request,
-                        status: 'error',
+                        status: CoreToolCallStatus.Error,
                         tool: toolInstance,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                         response: auxiliaryData,
                         durationMs,
                         outcome,
+                        approvalMode,
                     };
                 }
-                case 'awaiting_approval':
+                case CoreToolCallStatus.AwaitingApproval:
                     return {
                         request: currentCall.request,
                         tool: toolInstance,
-                        status: 'awaiting_approval',
-                        confirmationDetails: auxiliaryData,
+                        status: CoreToolCallStatus.AwaitingApproval,
+                        confirmationDetails: 
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                        auxiliaryData,
                         startTime: existingStartTime,
                         outcome,
                         invocation,
+                        approvalMode,
                     };
-                case 'scheduled':
+                case CoreToolCallStatus.Scheduled:
                     return {
                         request: currentCall.request,
                         tool: toolInstance,
-                        status: 'scheduled',
+                        status: CoreToolCallStatus.Scheduled,
                         startTime: existingStartTime,
                         outcome,
                         invocation,
+                        approvalMode,
                     };
-                case 'cancelled': {
+                case CoreToolCallStatus.Cancelled: {
                     const durationMs = existingStartTime
                         ? Date.now() - existingStartTime
                         : undefined;
                     // Preserve diff for cancelled edit operations
                     let resultDisplay = undefined;
-                    if (currentCall.status === 'awaiting_approval') {
+                    if (currentCall.status === CoreToolCallStatus.AwaitingApproval) {
                         const waitingCall = currentCall;
                         if (waitingCall.confirmationDetails.type === 'edit') {
                             resultDisplay = {
@@ -156,6 +166,7 @@ export class CoreToolScheduler {
                                 fileName: waitingCall.confirmationDetails.fileName,
                                 originalContent: waitingCall.confirmationDetails.originalContent,
                                 newContent: waitingCall.confirmationDetails.newContent,
+                                filePath: waitingCall.confirmationDetails.filePath,
                             };
                         }
                     }
@@ -164,7 +175,7 @@ export class CoreToolScheduler {
                         request: currentCall.request,
                         tool: toolInstance,
                         invocation,
-                        status: 'cancelled',
+                        status: CoreToolCallStatus.Cancelled,
                         response: {
                             callId: currentCall.request.callId,
                             responseParts: [
@@ -185,25 +196,28 @@ export class CoreToolScheduler {
                         },
                         durationMs,
                         outcome,
+                        approvalMode,
                     };
                 }
-                case 'validating':
+                case CoreToolCallStatus.Validating:
                     return {
                         request: currentCall.request,
                         tool: toolInstance,
-                        status: 'validating',
+                        status: CoreToolCallStatus.Validating,
                         startTime: existingStartTime,
                         outcome,
                         invocation,
+                        approvalMode,
                     };
-                case 'executing':
+                case CoreToolCallStatus.Executing:
                     return {
                         request: currentCall.request,
                         tool: toolInstance,
-                        status: 'executing',
+                        status: CoreToolCallStatus.Executing,
                         startTime: existingStartTime,
                         outcome,
                         invocation,
+                        approvalMode,
                     };
                 default: {
                     const exhaustiveCheck = newStatus;
@@ -217,21 +231,27 @@ export class CoreToolScheduler {
         this.toolCalls = this.toolCalls.map((call) => {
             // We should never be asked to set args on an ErroredToolCall, but
             // we guard for the case anyways.
-            if (call.request.callId !== targetCallId || call.status === 'error') {
+            if (call.request.callId !== targetCallId ||
+                call.status === CoreToolCallStatus.Error) {
                 return call;
             }
-            const invocationOrError = this.buildInvocation(call.tool, args);
+            const invocationOrError = this.buildInvocation(call.tool, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            args);
             if (invocationOrError instanceof Error) {
                 const response = createErrorResponse(call.request, invocationOrError, ToolErrorType.INVALID_TOOL_PARAMS);
                 return {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                     request: { ...call.request, args: args },
-                    status: 'error',
+                    status: CoreToolCallStatus.Error,
                     tool: call.tool,
                     response,
+                    approvalMode: call.approvalMode,
                 };
             }
             return {
                 ...call,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 request: { ...call.request, args: args },
                 invocation: invocationOrError,
             };
@@ -239,7 +259,8 @@ export class CoreToolScheduler {
     }
     isRunning() {
         return (this.isFinalizingToolCalls ||
-            this.toolCalls.some((call) => call.status === 'executing' || call.status === 'awaiting_approval'));
+            this.toolCalls.some((call) => call.status === CoreToolCallStatus.Executing ||
+                call.status === CoreToolCallStatus.AwaitingApproval));
     }
     buildInvocation(tool, args) {
         try {
@@ -292,11 +313,11 @@ export class CoreToolScheduler {
         if (this.toolCalls.length > 0) {
             const activeCall = this.toolCalls[0];
             // Only cancel if it's in a cancellable state.
-            if (activeCall.status === 'awaiting_approval' ||
-                activeCall.status === 'executing' ||
-                activeCall.status === 'scheduled' ||
-                activeCall.status === 'validating') {
-                this.setStatusInternal(activeCall.request.callId, 'cancelled', signal, 'User cancelled the operation.');
+            if (activeCall.status === CoreToolCallStatus.AwaitingApproval ||
+                activeCall.status === CoreToolCallStatus.Executing ||
+                activeCall.status === CoreToolCallStatus.Scheduled ||
+                activeCall.status === CoreToolCallStatus.Validating) {
+                this.setStatusInternal(activeCall.request.callId, CoreToolCallStatus.Cancelled, signal, 'User cancelled the operation.');
             }
         }
         // Clear the queue and mark all queued items as cancelled for completion reporting.
@@ -312,6 +333,7 @@ export class CoreToolScheduler {
                 throw new Error('Cannot schedule new tool calls while other tool calls are actively running (executing or awaiting approval).');
             }
             const requestsToProcess = Array.isArray(request) ? request : [request];
+            const currentApprovalMode = this.config.getApprovalMode();
             this.completedToolCallsForBatch = [];
             const newToolCalls = requestsToProcess.map((reqInfo) => {
                 const toolInstance = this.config
@@ -321,28 +343,31 @@ export class CoreToolScheduler {
                     const suggestion = getToolSuggestion(reqInfo.name, this.config.getToolRegistry().getAllToolNames());
                     const errorMessage = `Tool "${reqInfo.name}" not found in registry. Tools must use the exact names that are registered.${suggestion}`;
                     return {
-                        status: 'error',
+                        status: CoreToolCallStatus.Error,
                         request: reqInfo,
                         response: createErrorResponse(reqInfo, new Error(errorMessage), ToolErrorType.TOOL_NOT_REGISTERED),
                         durationMs: 0,
+                        approvalMode: currentApprovalMode,
                     };
                 }
                 const invocationOrError = this.buildInvocation(toolInstance, reqInfo.args);
                 if (invocationOrError instanceof Error) {
                     return {
-                        status: 'error',
+                        status: CoreToolCallStatus.Error,
                         request: reqInfo,
                         tool: toolInstance,
                         response: createErrorResponse(reqInfo, invocationOrError, ToolErrorType.INVALID_TOOL_PARAMS),
                         durationMs: 0,
+                        approvalMode: currentApprovalMode,
                     };
                 }
                 return {
-                    status: 'validating',
+                    status: CoreToolCallStatus.Validating,
                     request: reqInfo,
                     tool: toolInstance,
                     invocation: invocationOrError,
                     startTime: Date.now(),
+                    approvalMode: currentApprovalMode,
                 };
             });
             this.toolCallQueue.push(...newToolCalls);
@@ -369,41 +394,60 @@ export class CoreToolScheduler {
         this.toolCalls = [toolCall];
         this.notifyToolCallsUpdate();
         // Handle tools that were already errored during creation.
-        if (toolCall.status === 'error') {
+        if (toolCall.status === CoreToolCallStatus.Error) {
             // An error during validation means this "active" tool is already complete.
             // We need to check for batch completion to either finish or process the next in queue.
             await this.checkAndNotifyCompletion(signal);
             return;
         }
         // This logic is moved from the old `for` loop in `_schedule`.
-        if (toolCall.status === 'validating') {
+        if (toolCall.status === CoreToolCallStatus.Validating) {
             const { request: reqInfo, invocation } = toolCall;
             try {
                 if (signal.aborted) {
-                    this.setStatusInternal(reqInfo.callId, 'cancelled', signal, 'Tool call cancelled by user.');
+                    this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Cancelled, signal, 'Tool call cancelled by user.');
                     // The completion check will handle the cascade.
                     await this.checkAndNotifyCompletion(signal);
                     return;
                 }
-                const confirmationDetails = await invocation.shouldConfirmExecute(signal);
-                if (!confirmationDetails) {
+                // Policy Check using PolicyEngine
+                // We must reconstruct the FunctionCall format expected by PolicyEngine
+                const toolCallForPolicy = {
+                    name: toolCall.request.name,
+                    args: toolCall.request.args,
+                };
+                const serverName = toolCall.tool instanceof DiscoveredMCPTool
+                    ? toolCall.tool.serverName
+                    : undefined;
+                const { decision, rule } = await this.config
+                    .getPolicyEngine()
+                    .check(toolCallForPolicy, serverName);
+                if (decision === PolicyDecision.DENY) {
+                    const { errorMessage, errorType } = getPolicyDenialError(this.config, rule);
+                    this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Error, signal, createErrorResponse(reqInfo, new Error(errorMessage), errorType));
+                    await this.checkAndNotifyCompletion(signal);
+                    return;
+                }
+                if (decision === PolicyDecision.ALLOW) {
                     this.setToolCallOutcome(reqInfo.callId, ToolConfirmationOutcome.ProceedAlways);
-                    this.setStatusInternal(reqInfo.callId, 'scheduled', signal);
+                    this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Scheduled, signal);
                 }
                 else {
-                    if (this.isAutoApproved(toolCall)) {
+                    // PolicyDecision.ASK_USER
+                    // We need confirmation details to show to the user
+                    const confirmationDetails = await invocation.shouldConfirmExecute(signal);
+                    if (!confirmationDetails) {
                         this.setToolCallOutcome(reqInfo.callId, ToolConfirmationOutcome.ProceedAlways);
-                        this.setStatusInternal(reqInfo.callId, 'scheduled', signal);
+                        this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Scheduled, signal);
                     }
                     else {
                         if (!this.config.isInteractive()) {
                             throw new Error(`Tool execution for "${toolCall.tool.displayName || toolCall.tool.name}" requires user confirmation, which is not supported in non-interactive mode.`);
                         }
                         // Fire Notification hook before showing confirmation to user
-                        const messageBus = this.config.getMessageBus();
-                        const hooksEnabled = this.config.getEnableHooks();
-                        if (hooksEnabled && messageBus) {
-                            await fireToolNotificationHook(messageBus, confirmationDetails);
+                        const hookSystem = this.config.getHookSystem();
+                        if (hookSystem) {
+                            await hookSystem.fireToolNotificationEvent(confirmationDetails);
                         }
                         // Allow IDE to resolve confirmation
                         if (confirmationDetails.type === 'edit' &&
@@ -425,17 +469,17 @@ export class CoreToolScheduler {
                             ...confirmationDetails,
                             onConfirm: (outcome, payload) => this.handleConfirmationResponse(reqInfo.callId, originalOnConfirm, outcome, signal, payload),
                         };
-                        this.setStatusInternal(reqInfo.callId, 'awaiting_approval', signal, wrappedConfirmationDetails);
+                        this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.AwaitingApproval, signal, wrappedConfirmationDetails);
                     }
                 }
             }
             catch (error) {
                 if (signal.aborted) {
-                    this.setStatusInternal(reqInfo.callId, 'cancelled', signal, 'Tool call cancelled by user.');
+                    this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Cancelled, signal, 'Tool call cancelled by user.');
                     await this.checkAndNotifyCompletion(signal);
                 }
                 else {
-                    this.setStatusInternal(reqInfo.callId, 'error', signal, createErrorResponse(reqInfo, error instanceof Error ? error : new Error(String(error)), ToolErrorType.UNHANDLED_EXCEPTION));
+                    this.setStatusInternal(reqInfo.callId, CoreToolCallStatus.Error, signal, createErrorResponse(reqInfo, error instanceof Error ? error : new Error(String(error)), ToolErrorType.UNHANDLED_EXCEPTION));
                     await this.checkAndNotifyCompletion(signal);
                 }
             }
@@ -443,8 +487,9 @@ export class CoreToolScheduler {
         await this.attemptExecutionOfScheduledCalls(signal);
     }
     async handleConfirmationResponse(callId, originalOnConfirm, outcome, signal, payload) {
-        const toolCall = this.toolCalls.find((c) => c.request.callId === callId && c.status === 'awaiting_approval');
-        if (toolCall && toolCall.status === 'awaiting_approval') {
+        const toolCall = this.toolCalls.find((c) => c.request.callId === callId &&
+            c.status === CoreToolCallStatus.AwaitingApproval);
+        if (toolCall && toolCall.status === CoreToolCallStatus.AwaitingApproval) {
             await originalOnConfirm(outcome);
         }
         this.setToolCallOutcome(callId, outcome);
@@ -454,73 +499,73 @@ export class CoreToolScheduler {
             return; // `cancelAll` calls `checkAndNotifyCompletion`, so we can exit here.
         }
         else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             const waitingToolCall = toolCall;
-            if (isModifiableDeclarativeTool(waitingToolCall.tool)) {
-                const modifyContext = waitingToolCall.tool.getModifyContext(signal);
-                const editorType = this.getPreferredEditor();
-                if (!editorType) {
-                    return;
-                }
-                this.setStatusInternal(callId, 'awaiting_approval', signal, {
+            const editorType = this.getPreferredEditor();
+            if (!editorType) {
+                return;
+            }
+            /* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+            this.setStatusInternal(callId, CoreToolCallStatus.AwaitingApproval, signal, {
+                ...waitingToolCall.confirmationDetails,
+                isModifying: true,
+            });
+            /* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
+            const result = await this.toolModifier.handleModifyWithEditor(waitingToolCall, editorType, signal);
+            // Restore status (isModifying: false) and update diff if result exists
+            if (result) {
+                this.setArgsInternal(callId, result.updatedParams);
+                /* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+                this.setStatusInternal(callId, CoreToolCallStatus.AwaitingApproval, signal, {
                     ...waitingToolCall.confirmationDetails,
-                    isModifying: true,
+                    fileDiff: result.updatedDiff,
+                    isModifying: false,
                 });
-                const contentOverrides = waitingToolCall.confirmationDetails.type === 'edit'
-                    ? {
-                        currentContent: waitingToolCall.confirmationDetails.originalContent,
-                        proposedContent: waitingToolCall.confirmationDetails.newContent,
-                    }
-                    : undefined;
-                const { updatedParams, updatedDiff } = await modifyWithEditor(waitingToolCall.request.args, modifyContext, editorType, signal, contentOverrides);
-                this.setArgsInternal(callId, updatedParams);
-                this.setStatusInternal(callId, 'awaiting_approval', signal, {
+                /* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
+            }
+            else {
+                /* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+                this.setStatusInternal(callId, CoreToolCallStatus.AwaitingApproval, signal, {
                     ...waitingToolCall.confirmationDetails,
-                    fileDiff: updatedDiff,
                     isModifying: false,
                 });
+                /* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
             }
         }
         else {
-            // If the client provided new content, apply it before scheduling.
-            if (payload?.newContent && toolCall) {
-                await this._applyInlineModify(toolCall, payload, signal);
+            // If the client provided new content, apply it and wait for
+            // re-confirmation.
+            if (payload && 'newContent' in payload && toolCall) {
+                const result = await this.toolModifier.applyInlineModify(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                toolCall, payload, signal);
+                if (result) {
+                    this.setArgsInternal(callId, result.updatedParams);
+                    /* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+                    this.setStatusInternal(callId, CoreToolCallStatus.AwaitingApproval, signal, {
+                        ...toolCall.confirmationDetails,
+                        fileDiff: result.updatedDiff,
+                    });
+                    /* eslint-enable @typescript-eslint/no-unsafe-type-assertion */
+                    // After an inline modification, wait for another user confirmation.
+                    return;
+                }
             }
-            this.setStatusInternal(callId, 'scheduled', signal);
+            this.setStatusInternal(callId, CoreToolCallStatus.Scheduled, signal);
         }
         await this.attemptExecutionOfScheduledCalls(signal);
     }
-    /**
-     * Applies user-provided content changes to a tool call that is awaiting confirmation.
-     * This method updates the tool's arguments and refreshes the confirmation prompt with a new diff
-     * before the tool is scheduled for execution.
-     * @private
-     */
-    async _applyInlineModify(toolCall, payload, signal) {
-        if (toolCall.confirmationDetails.type !== 'edit' ||
-            !isModifiableDeclarativeTool(toolCall.tool)) {
-            return;
-        }
-        const modifyContext = toolCall.tool.getModifyContext(signal);
-        const currentContent = await modifyContext.getCurrentContent(toolCall.request.args);
-        const updatedParams = modifyContext.createUpdatedParams(currentContent, payload.newContent, toolCall.request.args);
-        const updatedDiff = Diff.createPatch(modifyContext.getFilePath(toolCall.request.args), currentContent, payload.newContent, 'Current', 'Proposed');
-        this.setArgsInternal(toolCall.request.callId, updatedParams);
-        this.setStatusInternal(toolCall.request.callId, 'awaiting_approval', signal, {
-            ...toolCall.confirmationDetails,
-            fileDiff: updatedDiff,
-        });
-    }
     async attemptExecutionOfScheduledCalls(signal) {
-        const allCallsFinalOrScheduled = this.toolCalls.every((call) => call.status === 'scheduled' ||
-            call.status === 'cancelled' ||
-            call.status === 'success' ||
-            call.status === 'error');
+        const allCallsFinalOrScheduled = this.toolCalls.every((call) => call.status === CoreToolCallStatus.Scheduled ||
+            call.status === CoreToolCallStatus.Cancelled ||
+            call.status === CoreToolCallStatus.Success ||
+            call.status === CoreToolCallStatus.Error);
         if (allCallsFinalOrScheduled) {
-            const callsToExecute = this.toolCalls.filter((call) => call.status === 'scheduled');
+            const callsToExecute = this.toolCalls.filter((call) => call.status === CoreToolCallStatus.Scheduled);
             for (const toolCall of callsToExecute) {
-                if (toolCall.status !== 'scheduled')
+                if (toolCall.status !== CoreToolCallStatus.Scheduled)
                     continue;
-                this.setStatusInternal(toolCall.request.callId, 'executing', signal);
+                this.setStatusInternal(toolCall.request.callId, CoreToolCallStatus.Executing, signal);
                 const executingCall = this.toolCalls.find((c) => c.request.callId === toolCall.request.callId);
                 if (!executingCall) {
                     // Should not happen, but safe guard
@@ -533,7 +578,8 @@ export class CoreToolScheduler {
                         if (this.outputUpdateHandler) {
                             this.outputUpdateHandler(callId, output);
                         }
-                        this.toolCalls = this.toolCalls.map((tc) => tc.request.callId === callId && tc.status === 'executing'
+                        this.toolCalls = this.toolCalls.map((tc) => tc.request.callId === callId &&
+                            tc.status === CoreToolCallStatus.Executing
                             ? { ...tc, liveOutput: output }
                             : tc);
                         this.notifyToolCallsUpdate();
@@ -546,7 +592,7 @@ export class CoreToolScheduler {
                     },
                 });
                 this.toolCalls = this.toolCalls.map((tc) => tc.request.callId === completedCall.request.callId
-                    ? completedCall
+                    ? { ...completedCall, approvalMode: tc.approvalMode }
                     : tc);
                 this.notifyToolCallsUpdate();
                 await this.checkAndNotifyCompletion(signal);
@@ -563,10 +609,10 @@ export class CoreToolScheduler {
         }
         else {
             const activeCall = this.toolCalls[0];
-            const isTerminal = activeCall.status === 'success' ||
-                activeCall.status === 'error' ||
-                activeCall.status === 'cancelled';
-            // If the active tool is not in a terminal state (e.g., it's 'executing' or 'awaiting_approval'),
+            const isTerminal = activeCall.status === CoreToolCallStatus.Success ||
+                activeCall.status === CoreToolCallStatus.Error ||
+                activeCall.status === CoreToolCallStatus.Cancelled;
+            // If the active tool is not in a terminal state (e.g., it's CoreToolCallStatus.Executing or CoreToolCallStatus.AwaitingApproval),
             // then the scheduler is still busy or paused. We should not proceed.
             if (!isTerminal) {
                 return;
@@ -630,7 +676,7 @@ export class CoreToolScheduler {
         while (this.toolCallQueue.length > 0) {
             const queuedCall = this.toolCallQueue.shift();
             // Don't cancel tools that already errored during validation.
-            if (queuedCall.status === 'error') {
+            if (queuedCall.status === CoreToolCallStatus.Error) {
                 this.completedToolCallsForBatch.push(queuedCall);
                 continue;
             }
@@ -642,7 +688,7 @@ export class CoreToolScheduler {
                 request: queuedCall.request,
                 tool: queuedCall.tool,
                 invocation: queuedCall.invocation,
-                status: 'cancelled',
+                status: CoreToolCallStatus.Cancelled,
                 response: {
                     callId: queuedCall.request.callId,
                     responseParts: [
@@ -663,6 +709,7 @@ export class CoreToolScheduler {
                 },
                 durationMs,
                 outcome: ToolConfirmationOutcome.Cancel,
+                approvalMode: queuedCall.approvalMode,
             });
         }
     }
@@ -685,17 +732,5 @@ export class CoreToolScheduler {
             };
         });
     }
-    isAutoApproved(toolCall) {
-        if (this.config.getApprovalMode() === ApprovalMode.YOLO) {
-            return true;
-        }
-        const allowedTools = this.config.getAllowedTools() || [];
-        const { tool, invocation } = toolCall;
-        const toolName = typeof tool === 'string' ? tool : tool.name;
-        if (SHELL_TOOL_NAMES.includes(toolName)) {
-            return isShellInvocationAllowlisted(invocation, allowedTools);
-        }
-        return doesToolInvocationMatch(tool, invocation, allowedTools);
-    }
 }
 //# sourceMappingURL=coreToolScheduler.js.map