@vybestack/llxprt-code-agents 0.10.0-nightly.260613.1adad3b34

package/dist/src/agents/executor.js

@@ -0,0 +1,874 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { reportError } from '@vybestack/llxprt-code-core/utils/errorReporting.js';
+import { ChatSession, StreamEventType, } from '../core/chatSession.js';
+import { Type } from '@google/genai';
+import { loadAgentRuntime } from '@vybestack/llxprt-code-core/runtime/AgentRuntimeLoader.js';
+import { createSettingsProviderRuntimeContext } from '@vybestack/llxprt-code-core/runtime/settingsRuntimeAdapter.js';
+import { createAgentRuntimeStateFromConfig } from '@vybestack/llxprt-code-core/runtime/runtimeStateFactory.js';
+import { executeToolCall } from '../core/nonInteractiveToolExecutor.js';
+import { filterHookRestrictedFunctionCalls, filterHookRestrictedParts, getHookRestrictedAllowedTools, getHookRestrictedAllowedToolsForFunctionCall, getHookRestrictedFunctionCallsFromParts, hasFilteredHookRestrictedToolCalls, isHookRestrictedToolCall, mergeHookRestrictedFunctionCalls, } from '../core/hookToolRestrictions.js';
+import { ToolRegistry } from '@vybestack/llxprt-code-tools';
+import { CoreMessageBusAdapter } from '@vybestack/llxprt-code-core/tools-adapters/CoreMessageBusAdapter.js';
+import { CoreToolRegistryHostAdapter } from '@vybestack/llxprt-code-core/tools-adapters/CoreToolRegistryHostAdapter.js';
+import { AgentTerminateMode } from './types.js';
+import { validateToolsForNonInteractiveUse } from './executor-validation.js';
+import { buildAgentSystemPrompt, applyTemplateToInitialMessages, } from './executor-prompt-builder.js';
+import { checkAgentTermination } from './executor-termination.js';
+import { resolveGracePeriodSeconds, isRecoverableTermination, enterRecovery, recoveryFailureResult, markRecoveryResponseUsed, } from './recovery.js';
+import { templateString } from './utils.js';
+import { parseThought } from '@vybestack/llxprt-code-core/utils/thoughtUtils.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { debugLogger } from '@vybestack/llxprt-code-core/utils/debugLogger.js';
+import { createAbortError } from '@vybestack/llxprt-code-core/utils/delay.js';
+import { nextStreamEventWithIdleTimeout, resolveStreamIdleTimeoutMs, } from '@vybestack/llxprt-code-core/utils/streamIdleTimeout.js';
+const TASK_COMPLETE_TOOL_NAME = 'complete_task';
+/**
+ * Executes an agent loop based on an {@link AgentDefinition}.
+ *
+ * This executor runs the agent in a loop, calling tools until it calls the
+ * mandatory `complete_task` tool to signal completion.
+ */
+export class AgentExecutor {
+    definition;
+    agentId;
+    toolRegistry;
+    runtimeContext;
+    messageBus;
+    onActivity;
+    /**
+     * Creates and validates a new `AgentExecutor` instance.
+     *
+     * This method ensures that all tools specified in the agent's definition are
+     * safe for non-interactive use before creating the executor.
+     *
+     * @param definition The definition object for the agent.
+     * @param runtimeContext The global runtime configuration.
+     * @param onActivity An optional callback to receive activity events.
+     * @returns A promise that resolves to a new `AgentExecutor` instance.
+     */
+    /**
+     * @plan PLAN-20260309-MESSAGEBUS-DI-REMEDIATION.P05
+     * @requirement REQ-D01-001.2
+     * @pseudocode lines 56-72
+     */
+    static async create(definition, runtimeContext, messageBus, onActivity) {
+        /**
+         * @plan PLAN-20260309-MESSAGEBUS-DI-REMEDIATION.P05
+         * @requirement REQ-D01-001.2
+         * @pseudocode lines 56-72
+         */
+        const agentToolRegistry = new ToolRegistry(new CoreToolRegistryHostAdapter(runtimeContext), new CoreMessageBusAdapter(messageBus));
+        const parentToolRegistry = runtimeContext.getToolRegistry();
+        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);
+                    // eslint-disable-next-line sonarjs/nested-control-flow -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+                    if (toolFromParent) {
+                        agentToolRegistry.registerTool(toolFromParent);
+                    }
+                }
+                else if (typeof toolRef === 'object' &&
+                    'name' in toolRef &&
+                    'build' in toolRef) {
+                    agentToolRegistry.registerTool(toolRef);
+                }
+                // Note: Raw `FunctionDeclaration` objects in the config don't need to be
+                // registered; their schemas are passed directly to the model later.
+            }
+            agentToolRegistry.sortTools();
+            // Validate that all registered tools are safe for non-interactive
+            // execution.
+            await validateToolsForNonInteractiveUse(agentToolRegistry, definition.name);
+        }
+        return new AgentExecutor(definition, runtimeContext, agentToolRegistry, messageBus, onActivity);
+    }
+    /**
+     * Constructs a new AgentExecutor instance.
+     *
+     * @private This constructor is private. Use the static `create` method to
+     * instantiate the class.
+     */
+    constructor(definition, runtimeContext, toolRegistry, messageBus, onActivity) {
+        this.definition = definition;
+        this.runtimeContext = runtimeContext;
+        this.toolRegistry = toolRegistry;
+        this.messageBus = messageBus;
+        this.onActivity = onActivity;
+        const randomIdPart = Math.random().toString(36).slice(2, 8);
+        this.agentId = `${this.definition.name}-${randomIdPart}`;
+    }
+    /**
+     * Runs the agent.
+     *
+     * @param inputs The validated input parameters for this invocation.
+     * @param signal An `AbortSignal` for cancellation.
+     * @returns A promise that resolves to the agent's final output.
+     */
+    async run(inputs, signal) {
+        const startTime = Date.now();
+        try {
+            const chat = await this.createChatObject(inputs);
+            const tools = this.prepareToolsList();
+            const query = this.definition.promptConfig.query
+                ? templateString(this.definition.promptConfig.query, inputs)
+                : 'Get Started!';
+            const initialMessage = {
+                role: 'user',
+                parts: [{ text: query }],
+            };
+            const { terminateReason, finalResult } = await this.runAgentLoop(chat, tools, initialMessage, signal, startTime, 0);
+            if (terminateReason === AgentTerminateMode.GOAL) {
+                return {
+                    result: finalResult ?? 'Task completed.',
+                    terminate_reason: terminateReason,
+                };
+            }
+            return {
+                result: finalResult ?? 'Agent execution was terminated before completion.',
+                terminate_reason: terminateReason,
+            };
+        }
+        catch (error) {
+            this.emitActivity('ERROR', { error: String(error) });
+            throw error;
+        }
+    }
+    /** Runs the agent loop until termination, returning the reason and result. */
+    async runAgentLoop(chat, tools, initialMessage, signal, startTime, turnCounter) {
+        let finalResult = null;
+        let currentMessage = initialMessage;
+        let recoveryState = { phase: 'none' };
+        let recoveryModelResponseUsed = false;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Agent/model streams are external runtime boundaries.
+        while (true) {
+            const outcome = await this.runAgentLoopIteration(chat, tools, signal, startTime, turnCounter, finalResult, currentMessage, recoveryState, recoveryModelResponseUsed);
+            if (outcome.kind === 'continue') {
+                recoveryState = outcome.recoveryState;
+                currentMessage = outcome.currentMessage;
+                if (outcome.recoveryModelResponseUsed !== undefined) {
+                    recoveryModelResponseUsed = outcome.recoveryModelResponseUsed;
+                }
+                turnCounter = outcome.turnCounter;
+                finalResult = outcome.finalResult;
+            }
+            else {
+                return outcome.result;
+            }
+        }
+    }
+    /** Single iteration of the agent loop. */
+    async runAgentLoopIteration(chat, tools, signal, startTime, turnCounter, finalResult, currentMessage, recoveryState, recoveryModelResponseUsed) {
+        const recoveryDeadlineMs = recoveryState.phase === 'active' ? recoveryState.deadlineMs : undefined;
+        const reason = this.checkTermination(startTime, turnCounter, recoveryDeadlineMs);
+        if (reason !== null) {
+            const termOutcome = this.handleTerminationReason(reason, recoveryState, finalResult);
+            if (termOutcome.handled) {
+                return {
+                    kind: 'continue',
+                    recoveryState: termOutcome.newState,
+                    currentMessage: termOutcome.currentMessage,
+                    recoveryModelResponseUsed: undefined,
+                    turnCounter,
+                    finalResult,
+                };
+            }
+            return { kind: 'done', result: termOutcome.result };
+        }
+        return this.runAgentLoopIterationBody(chat, tools, signal, startTime, turnCounter, finalResult, currentMessage, recoveryState, recoveryModelResponseUsed);
+    }
+    /** Body of the agent loop iteration (after termination checks). */
+    // eslint-disable-next-line max-lines-per-function -- Agent iteration orchestration coordinates model calls, recovery handling, and tool dispatch in one control-flow boundary.
+    async runAgentLoopIterationBody(chat, tools, signal, startTime, turnCounter, finalResult, currentMessage, recoveryState, recoveryModelResponseUsed) {
+        if (signal.aborted) {
+            return {
+                kind: 'done',
+                result: { terminateReason: AgentTerminateMode.ABORTED, finalResult },
+            };
+        }
+        const recoveryAbort = recoveryState.phase === 'active' && !recoveryModelResponseUsed
+            ? this.createRecoveryAbortController(recoveryState.deadlineMs, signal)
+            : undefined;
+        const promptId = `${this.runtimeContext.getSessionId()}#${this.agentId}#${turnCounter}`;
+        const nextTurnCounter = turnCounter + 1;
+        let modelResult;
+        let functionCalls;
+        try {
+            modelResult = await this.callModel(chat, currentMessage, tools, recoveryAbort?.signal ?? signal, promptId);
+            functionCalls = modelResult.functionCalls;
+        }
+        catch (error) {
+            if (recoveryState.phase === 'active') {
+                // If the parent signal was aborted, terminate as ABORTED rather than
+                // emitting a misleading recovery-timeout outcome.
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- signal.aborted can be true even though the outer already-gated check passed; the catch path is reached from callModel which can throw on abort.
+                if (signal.aborted) {
+                    return {
+                        kind: 'done',
+                        result: {
+                            terminateReason: AgentTerminateMode.ABORTED,
+                            finalResult,
+                        },
+                    };
+                }
+                this.emitRecoveryOutcome(recoveryState.originalReason, 'failure', recoveryState.originalReason, recoveryState.gracePeriodSeconds);
+                return {
+                    kind: 'done',
+                    result: {
+                        terminateReason: recoveryState.originalReason,
+                        finalResult: finalResult ?? 'Recovery turn timed out.',
+                    },
+                };
+            }
+            throw error;
+        }
+        finally {
+            recoveryAbort?.abort();
+        }
+        const newRecoveryModelResponseUsed = markRecoveryResponseUsed(recoveryState, recoveryModelResponseUsed);
+        if (this.isAborted(signal)) {
+            return {
+                kind: 'done',
+                result: { terminateReason: AgentTerminateMode.ABORTED, finalResult },
+            };
+        }
+        const checkResult = this.checkRecoveryToolCalls(recoveryState, newRecoveryModelResponseUsed, functionCalls, finalResult);
+        if (checkResult) {
+            return { kind: 'done', result: checkResult };
+        }
+        if (functionCalls.length === 0) {
+            const enterResult = this.handleProtocolViolation(recoveryState, finalResult);
+            if (enterResult.entered) {
+                return {
+                    kind: 'continue',
+                    recoveryState: enterResult.state,
+                    currentMessage: enterResult.warningMessage,
+                    recoveryModelResponseUsed: false,
+                    turnCounter: nextTurnCounter,
+                    finalResult,
+                };
+            }
+            const activeGrace = recoveryState.phase === 'active' ? recoveryState.gracePeriodSeconds : 0;
+            this.emitRecoveryOutcome(enterResult.result.terminateReason, 'failure', enterResult.result.terminateReason, activeGrace);
+            return { kind: 'done', result: enterResult.result };
+        }
+        const { nextMessage, submittedOutput, taskCompleted, partialResult } = await this.processFunctionCalls(functionCalls, signal, promptId);
+        if (taskCompleted) {
+            if (recoveryState.phase === 'active') {
+                this.emitRecoveryOutcome(recoveryState.originalReason, 'success', AgentTerminateMode.GOAL, recoveryState.gracePeriodSeconds);
+            }
+            finalResult = submittedOutput ?? 'Task completed successfully.';
+            return {
+                kind: 'done',
+                result: { terminateReason: AgentTerminateMode.GOAL, finalResult },
+            };
+        }
+        if (recoveryState.phase === 'active' && newRecoveryModelResponseUsed) {
+            const fail = recoveryFailureResult(recoveryState.originalReason, finalResult);
+            this.emitRecoveryOutcome(recoveryState.originalReason, 'failure', fail.terminateReason, recoveryState.gracePeriodSeconds);
+            return { kind: 'done', result: fail };
+        }
+        const nextFinalResult = partialResult ?? finalResult;
+        return {
+            kind: 'continue',
+            recoveryState,
+            currentMessage: nextMessage,
+            recoveryModelResponseUsed: newRecoveryModelResponseUsed,
+            turnCounter: nextTurnCounter,
+            finalResult: nextFinalResult,
+        };
+    }
+    /** Check tool calls during recovery: non-complete_task = recovery failure. */
+    checkRecoveryToolCalls(recoveryState, recoveryModelResponseUsed, functionCalls, finalResult) {
+        if (recoveryState.phase !== 'active' || !recoveryModelResponseUsed) {
+            return null;
+        }
+        const hasCompleteTask = functionCalls.some((fc) => fc.name === TASK_COMPLETE_TOOL_NAME);
+        if (!hasCompleteTask) {
+            this.emitRecoveryOutcome(recoveryState.originalReason, 'failure', recoveryState.originalReason, recoveryState.gracePeriodSeconds);
+            return recoveryFailureResult(recoveryState.originalReason, finalResult);
+        }
+        // Recovery response must be exactly one complete_task call.
+        // If complete_task is accompanied by other tools, fail recovery immediately
+        // and do not execute any of the tool calls.
+        if (functionCalls.length > 1) {
+            this.emitRecoveryOutcome(recoveryState.originalReason, 'failure', recoveryState.originalReason, recoveryState.gracePeriodSeconds);
+            return recoveryFailureResult(recoveryState.originalReason, finalResult);
+        }
+        return null;
+    }
+    /** Handle termination-reason checks: enter recovery or return immediately. */
+    handleTerminationReason(reason, recoveryState, finalResult) {
+        if (isRecoverableTermination(reason) && recoveryState.phase === 'none') {
+            const gracePeriodSeconds = resolveGracePeriodSeconds(this.definition.runConfig.grace_period_seconds);
+            const { state, warningMessage } = enterRecovery(reason, gracePeriodSeconds, (type, data) => this.emitActivity(type, data));
+            return { handled: true, newState: state, currentMessage: warningMessage };
+        }
+        if (recoveryState.phase === 'active') {
+            const fail = recoveryFailureResult(recoveryState.originalReason, finalResult);
+            this.emitRecoveryOutcome(recoveryState.originalReason, 'failure', fail.terminateReason, recoveryState.gracePeriodSeconds);
+            return { handled: false, result: fail };
+        }
+        return { handled: false, result: { terminateReason: reason, finalResult } };
+    }
+    /** Handle the protocol-violation path (model stopped calling tools). */
+    handleProtocolViolation(recoveryState, finalResult) {
+        if (recoveryState.phase === 'none') {
+            const gracePeriodSeconds = resolveGracePeriodSeconds(this.definition.runConfig.grace_period_seconds);
+            const { state, warningMessage } = enterRecovery(AgentTerminateMode.ERROR_NO_COMPLETE_TASK_CALL, gracePeriodSeconds, (type, data) => this.emitActivity(type, data));
+            return { entered: true, state, warningMessage };
+        }
+        // Already in recovery: the one recovery model response didn't call
+        // complete_task, so this empty response confirms recovery failure.
+        const fail = recoveryFailureResult(recoveryState.originalReason, finalResult);
+        return { entered: false, result: fail };
+    }
+    isAborted(signal) {
+        return signal.aborted;
+    }
+    /** Create an AbortController that fires when the recovery deadline passes. */
+    createRecoveryAbortController(deadlineMs, parentSignal) {
+        const controller = new AbortController();
+        const remaining = deadlineMs - Date.now();
+        const timer = setTimeout(() => controller.abort(), Math.max(0, remaining));
+        const onParentAbort = () => controller.abort();
+        parentSignal.addEventListener('abort', onParentAbort, { once: true });
+        // Clean up both when our controller fires
+        controller.signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            parentSignal.removeEventListener('abort', onParentAbort);
+        }, { once: true });
+        return controller;
+    }
+    /** Emit a RECOVERY_OUTCOME telemetry event. */
+    emitRecoveryOutcome(originalReason, outcome, terminateReason, gracePeriodSeconds) {
+        this.emitActivity('RECOVERY_OUTCOME', {
+            originalReason,
+            outcome,
+            terminateReason,
+            gracePeriodSeconds,
+        });
+    }
+    /**
+     * Calls the generative model with the current context and tools.
+     *
+     * @returns The model's response, including any tool calls or text.
+     */
+    async callModel(chat, message, tools, signal, promptId) {
+        const timeoutController = new AbortController();
+        const timeoutSignal = timeoutController.signal;
+        const onAbort = () => timeoutController.abort();
+        signal.addEventListener('abort', onAbort, { once: true });
+        const messageParams = {
+            message: message.parts ?? [],
+            config: {
+                abortSignal: timeoutSignal,
+                tools: tools.length > 0 ? [{ functionDeclarations: tools }] : undefined,
+            },
+        };
+        let streamIterator;
+        const effectiveTimeoutMs = resolveStreamIdleTimeoutMs(this.runtimeContext);
+        try {
+            const responseStream = await chat.sendMessageStream(messageParams, promptId);
+            const functionCalls = [];
+            let textResponse = '';
+            streamIterator = responseStream[Symbol.asyncIterator]();
+            await this.consumeStream(streamIterator, effectiveTimeoutMs, signal, timeoutSignal, timeoutController, functionCalls, (text) => {
+                textResponse += text;
+            });
+            return {
+                functionCalls,
+                textResponse,
+            };
+        }
+        finally {
+            streamIterator?.return?.().catch(() => { });
+            timeoutController.abort();
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+    /** Consumes a response stream, accumulating function calls and text. */
+    async consumeStream(streamIterator, effectiveTimeoutMs, signal, timeoutSignal, timeoutController, functionCalls, onText) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, sonarjs/too-many-break-or-continue-in-loop -- Agent/model streams are external runtime boundaries despite declared types.
+        while (true) {
+            let result;
+            if (effectiveTimeoutMs > 0) {
+                result = await nextStreamEventWithIdleTimeout({
+                    iterator: streamIterator,
+                    timeoutMs: effectiveTimeoutMs,
+                    signal: timeoutSignal,
+                    onTimeout: () => {
+                        if (signal.aborted) {
+                            return;
+                        }
+                        timeoutController.abort();
+                    },
+                    createTimeoutError: () => createAbortError(),
+                });
+            }
+            else {
+                result = await streamIterator.next();
+            }
+            if (result.done === true) {
+                break;
+            }
+            const resp = result.value;
+            if (signal.aborted)
+                break;
+            if (resp.type === StreamEventType.CHUNK) {
+                this.processStreamChunk(resp.value, functionCalls, onText);
+            }
+        }
+    }
+    /** Processes a single stream chunk, extracting thoughts, function calls, and text. */
+    processStreamChunk(chunk, functionCalls, onText) {
+        const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+        const allowedTools = getHookRestrictedAllowedTools(chunk);
+        const filteredParts = filterHookRestrictedParts(parts, allowedTools);
+        const { subject } = parseThought(filteredParts.find((p) => p.thought === true)?.text ?? '');
+        if (subject !== '') {
+            this.emitActivity('THOUGHT_CHUNK', { text: subject });
+        }
+        const partCalls = getHookRestrictedFunctionCallsFromParts(filteredParts, allowedTools);
+        const topLevelCalls = filterHookRestrictedFunctionCalls(chunk.functionCalls ?? [], allowedTools);
+        const allowedFunctionCalls = mergeHookRestrictedFunctionCalls(partCalls, topLevelCalls);
+        if (allowedFunctionCalls.length > 0) {
+            functionCalls.push(...allowedFunctionCalls);
+        }
+        const text = filteredParts
+            .filter((p) => p.thought !== true && typeof p.text === 'string')
+            .map((p) => p.text)
+            .join('');
+        if (text.length > 0) {
+            onText(text);
+        }
+        return hasFilteredHookRestrictedToolCalls(chunk);
+    }
+    /** Initializes a `ChatSession` instance for the agent run. */
+    async createChatObject(inputs) {
+        const { promptConfig, modelConfig } = this.definition;
+        if (!promptConfig.systemPrompt && !promptConfig.initialMessages) {
+            throw new Error('PromptConfig must define either `systemPrompt` or `initialMessages`.');
+        }
+        const startHistory = this.applyTemplateToInitialMessages(promptConfig.initialMessages ?? [], inputs);
+        const systemInstruction = promptConfig.systemPrompt
+            ? await this.buildSystemPrompt(inputs)
+            : undefined;
+        try {
+            const generationConfig = this.buildGenerationConfig(modelConfig, systemInstruction);
+            const runtimeBundle = await this.buildRuntimeBundle();
+            return new ChatSession(runtimeBundle.runtimeContext, runtimeBundle.contentGenerator, generationConfig, startHistory);
+        }
+        catch (error) {
+            await reportError(error, `Error initializing Gemini chat for agent ${this.definition.name}.`, startHistory, 'startChat');
+            throw new Error(`Failed to create chat object: ${error}`);
+        }
+    }
+    /** Builds the generation config from model config and optional system instruction. */
+    buildGenerationConfig(modelConfig, systemInstruction) {
+        const generationConfig = {
+            temperature: modelConfig.temp,
+            topP: modelConfig.top_p,
+            thinkingConfig: {
+                includeThoughts: true,
+                thinkingBudget: modelConfig.thinkingBudget ?? -1,
+            },
+        };
+        if (systemInstruction) {
+            generationConfig.systemInstruction = systemInstruction;
+        }
+        return generationConfig;
+    }
+    /** Builds the runtime bundle for the ChatSession instance. */
+    async buildRuntimeBundle() {
+        const settings = this.resolveSettingsSnapshot();
+        const runtimeState = createAgentRuntimeStateFromConfig(this.runtimeContext);
+        const providerRuntime = createSettingsProviderRuntimeContext({
+            settingsService: this.runtimeContext.getSettingsService(),
+            config: this.runtimeContext,
+            runtimeId: runtimeState.runtimeId,
+            metadata: { source: 'AgentExecutor.createChatObject' },
+        });
+        return loadAgentRuntime({
+            profile: {
+                config: this.runtimeContext,
+                state: runtimeState,
+                settings,
+                providerRuntime,
+                contentGeneratorConfig: this.runtimeContext.getContentGeneratorConfig(),
+                toolRegistry: this.toolRegistry,
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Agent/model streams are external runtime boundaries despite declared types.
+                providerManager: this.runtimeContext.getProviderManager?.(),
+            },
+            overrides: {
+                contentGenerator: this.tryGetContentGenerator(),
+            },
+        });
+    }
+    /** Resolves the settings snapshot from ephemeral config. */
+    resolveSettingsSnapshot() {
+        const rawCompressionThreshold = this.runtimeContext.getEphemeralSetting('compression-threshold');
+        const compressionThreshold = typeof rawCompressionThreshold === 'number'
+            ? rawCompressionThreshold
+            : 0.8;
+        const rawContextLimit = this.runtimeContext.getEphemeralSetting('context-limit');
+        const contextLimit = typeof rawContextLimit === 'number' &&
+            Number.isFinite(rawContextLimit) &&
+            rawContextLimit > 0
+            ? rawContextLimit
+            : undefined;
+        const rawPreserveThreshold = this.runtimeContext.getEphemeralSetting('compression-preserve-threshold');
+        const preserveThreshold = typeof rawPreserveThreshold === 'number' ? rawPreserveThreshold : 0.2;
+        return {
+            compressionThreshold,
+            contextLimit,
+            preserveThreshold,
+            telemetry: {
+                enabled: true,
+                target: null,
+            },
+        };
+    }
+    /** Attempts to get the content generator from the runtime context. */
+    tryGetContentGenerator() {
+        try {
+            return (this.runtimeContext
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Agent/model streams are external runtime boundaries despite declared types.
+                .getAgentClient?.()
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Agent/model streams are external runtime boundaries despite declared types.
+                ?.getContentGenerator());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Executes function calls requested by the model and returns the results.
+     *
+     * @returns A new `Content` object for history, any submitted output, and completion status.
+     */
+    async processFunctionCalls(functionCalls, signal, promptId) {
+        const allowedToolNames = new Set(this.toolRegistry.getAllToolNames());
+        allowedToolNames.add(TASK_COMPLETE_TOOL_NAME);
+        let submittedOutput = null;
+        let taskCompleted = false;
+        const toolExecutionPromises = [];
+        const syncResponseParts = [];
+        let executableFunctionCallCount = 0;
+        // eslint-disable-next-line sonarjs/too-many-break-or-continue-in-loop -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+        for (const [index, functionCall] of functionCalls.entries()) {
+            const callId = functionCall.id ?? `${promptId}-${index}`;
+            const args = functionCall.args ?? {};
+            const hookAllowedTools = getHookRestrictedAllowedToolsForFunctionCall(functionCall);
+            if (isHookRestrictedToolCall(functionCall, hookAllowedTools)) {
+                continue;
+            }
+            executableFunctionCallCount += 1;
+            this.emitActivity('TOOL_CALL_START', { name: functionCall.name, args });
+            if (functionCall.name === TASK_COMPLETE_TOOL_NAME) {
+                const result = this.handleCompleteTaskCall(functionCall, callId, args, taskCompleted, submittedOutput);
+                taskCompleted = result.taskCompleted;
+                submittedOutput = result.submittedOutput;
+                syncResponseParts.push(...result.syncParts);
+                continue;
+            }
+            if (!allowedToolNames.has(functionCall.name)) {
+                this.handleUnauthorizedToolCall(functionCall, callId, syncResponseParts);
+                continue;
+            }
+            toolExecutionPromises.push(this.createToolExecutionPromise(functionCall, callId, args, signal, promptId));
+        }
+        return this.assembleToolResponses(executableFunctionCallCount, syncResponseParts, toolExecutionPromises, submittedOutput, taskCompleted);
+    }
+    /** Handles a `complete_task` function call, returning updated state and response parts. */
+    handleCompleteTaskCall(functionCall, callId, args, currentTaskCompleted, currentSubmittedOutput) {
+        const syncParts = [];
+        if (currentTaskCompleted) {
+            const error = 'Task already marked complete in this turn. Ignoring duplicate call.';
+            syncParts.push({
+                functionResponse: {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    response: { error },
+                    id: callId,
+                },
+            });
+            this.emitActivity('ERROR', {
+                context: 'tool_call',
+                name: functionCall.name,
+                error,
+            });
+            return {
+                taskCompleted: currentTaskCompleted,
+                submittedOutput: currentSubmittedOutput,
+                syncParts,
+            };
+        }
+        const { outputConfig } = this.definition;
+        if (outputConfig) {
+            const result = this.processCompleteTaskOutput(functionCall, callId, args, outputConfig);
+            syncParts.push(...result.syncParts);
+            return {
+                taskCompleted: result.taskCompleted,
+                submittedOutput: result.submittedOutput,
+                syncParts,
+            };
+        }
+        syncParts.push({
+            functionResponse: {
+                name: TASK_COMPLETE_TOOL_NAME,
+                response: { status: 'Task marked complete.' },
+                id: callId,
+            },
+        });
+        this.emitActivity('TOOL_CALL_END', {
+            name: functionCall.name,
+            output: 'Task marked complete.',
+        });
+        return {
+            taskCompleted: true,
+            submittedOutput: 'Task completed successfully.',
+            syncParts,
+        };
+    }
+    /** Processes the output argument of a `complete_task` call when outputConfig is present. */
+    processCompleteTaskOutput(functionCall, callId, args, outputConfig) {
+        const syncParts = [];
+        const outputName = outputConfig.outputName;
+        if (args[outputName] !== undefined) {
+            const outputValue = args[outputName];
+            const validationResult = outputConfig.schema.safeParse(outputValue);
+            if (!validationResult.success) {
+                const error = `Output validation failed: ${JSON.stringify(validationResult.error.flatten())}`;
+                syncParts.push({
+                    functionResponse: {
+                        name: TASK_COMPLETE_TOOL_NAME,
+                        response: { error },
+                        id: callId,
+                    },
+                });
+                this.emitActivity('ERROR', {
+                    context: 'tool_call',
+                    name: functionCall.name,
+                    error,
+                });
+                return { taskCompleted: false, submittedOutput: null, syncParts };
+            }
+            const validatedOutput = validationResult.data;
+            let submittedOutput;
+            if (this.definition.processOutput) {
+                submittedOutput = this.definition.processOutput(validatedOutput);
+            }
+            else if (typeof outputValue === 'string') {
+                submittedOutput = outputValue;
+            }
+            else {
+                submittedOutput = JSON.stringify(outputValue, null, 2);
+            }
+            syncParts.push({
+                functionResponse: {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    response: { result: 'Output submitted and task completed.' },
+                    id: callId,
+                },
+            });
+            this.emitActivity('TOOL_CALL_END', {
+                name: functionCall.name,
+                output: 'Output submitted and task completed.',
+            });
+            return { taskCompleted: true, submittedOutput, syncParts };
+        }
+        // Missing required output argument
+        const error = `Missing required argument '${outputName}' for completion.`;
+        syncParts.push({
+            functionResponse: {
+                name: TASK_COMPLETE_TOOL_NAME,
+                response: { error },
+                id: callId,
+            },
+        });
+        this.emitActivity('ERROR', {
+            context: 'tool_call',
+            name: functionCall.name,
+            error,
+        });
+        return { taskCompleted: false, submittedOutput: null, syncParts };
+    }
+    /** Handles an unauthorized tool call by pushing an error response. */
+    handleUnauthorizedToolCall(functionCall, callId, syncResponseParts) {
+        const error = `Unauthorized tool call: '${functionCall.name}' is not available to this agent.`;
+        debugLogger.warn(`[AgentExecutor] Blocked call: ${error}`);
+        syncResponseParts.push({
+            functionResponse: {
+                name: functionCall.name,
+                id: callId,
+                response: { error },
+            },
+        });
+        this.emitActivity('ERROR', {
+            context: 'tool_call_unauthorized',
+            name: functionCall.name,
+            callId,
+            error,
+        });
+    }
+    /** Creates an async promise that executes a standard tool call. */
+    createToolExecutionPromise(functionCall, callId, args, signal, promptId) {
+        const hookAllowedTools = getHookRestrictedAllowedToolsForFunctionCall(functionCall);
+        const requestInfo = {
+            callId,
+            name: functionCall.name,
+            args,
+            isClientInitiated: true,
+            prompt_id: promptId,
+            ...(hookAllowedTools !== undefined
+                ? { hookRestrictedAllowedTools: hookAllowedTools }
+                : {}),
+        };
+        return (async () => {
+            const completed = await executeToolCall(this.runtimeContext, requestInfo, signal, { messageBus: this.messageBus });
+            const toolResponse = completed.response;
+            if (toolResponse.error) {
+                this.emitActivity('ERROR', {
+                    context: 'tool_call',
+                    name: functionCall.name,
+                    error: toolResponse.error.message,
+                });
+            }
+            else {
+                this.emitActivity('TOOL_CALL_END', {
+                    name: functionCall.name,
+                    output: toolResponse.resultDisplay,
+                });
+            }
+            return {
+                responseParts: toolResponse.responseParts,
+                partialResult: typeof toolResponse.resultDisplay === 'string'
+                    ? toolResponse.resultDisplay
+                    : null,
+            };
+        })();
+    }
+    /** Assembles all tool response parts and returns the final result. */
+    async assembleToolResponses(executableFunctionCallCount, syncResponseParts, toolExecutionPromises, submittedOutput, taskCompleted) {
+        const asyncResults = await Promise.all(toolExecutionPromises);
+        const toolResponseParts = [...syncResponseParts];
+        let partialResult = null;
+        for (const result of asyncResults) {
+            if (result) {
+                toolResponseParts.push(...result.responseParts);
+                if (result.partialResult !== null) {
+                    partialResult = result.partialResult;
+                }
+            }
+        }
+        if (executableFunctionCallCount > 0 &&
+            toolResponseParts.length === 0 &&
+            !taskCompleted) {
+            toolResponseParts.push({
+                text: 'All tool calls failed or were unauthorized. Please analyze the errors and try an alternative approach.',
+            });
+        }
+        return {
+            nextMessage: { role: 'user', parts: toolResponseParts },
+            submittedOutput,
+            taskCompleted,
+            partialResult,
+        };
+    }
+    /**
+     * Prepares the list of tool function declarations to be sent to the model.
+     */
+    prepareToolsList() {
+        const toolsList = [];
+        const { toolConfig, outputConfig } = this.definition;
+        if (toolConfig) {
+            const toolNamesToLoad = [];
+            for (const toolRef of toolConfig.tools) {
+                if (typeof toolRef === 'string') {
+                    toolNamesToLoad.push(toolRef);
+                }
+                else if (typeof toolRef === 'object' && 'schema' in toolRef) {
+                    // Tool instance with an explicit schema property.
+                    toolsList.push(toolRef.schema);
+                }
+                else {
+                    // Raw `FunctionDeclaration` object.
+                    toolsList.push(toolRef);
+                }
+            }
+            // Add schemas from tools that were registered by name.
+            toolsList.push(...this.toolRegistry.getFunctionDeclarationsFiltered(toolNamesToLoad));
+        }
+        // Always inject complete_task.
+        // Configure its schema based on whether output is expected.
+        const completeTool = {
+            name: TASK_COMPLETE_TOOL_NAME,
+            description: outputConfig
+                ? 'Call this tool to submit your final answer and complete the task. This is the ONLY way to finish.'
+                : 'Call this tool to signal that you have completed your task. This is the ONLY way to finish.',
+            parameters: {
+                type: Type.OBJECT,
+                properties: {},
+                required: [],
+            },
+        };
+        if (outputConfig) {
+            const jsonSchema = zodToJsonSchema(outputConfig.schema);
+            const { $schema: _$schema, definitions: _definitions, ...schema } = jsonSchema;
+            completeTool.parameters.properties[outputConfig.outputName] =
+                schema;
+            completeTool.parameters.required.push(outputConfig.outputName);
+        }
+        toolsList.push(completeTool);
+        return toolsList;
+    }
+    /** Builds the system prompt from the agent definition and inputs. */
+    async buildSystemPrompt(inputs) {
+        const { promptConfig } = this.definition;
+        if (!promptConfig.systemPrompt) {
+            return '';
+        }
+        return buildAgentSystemPrompt(inputs, this.runtimeContext, promptConfig.systemPrompt);
+    }
+    /**
+     * Applies template strings to initial messages.
+     *
+     * @param initialMessages The initial messages from the prompt config.
+     * @param inputs The validated input parameters for this invocation.
+     * @returns A new array of `Content` with templated strings.
+     */
+    applyTemplateToInitialMessages(initialMessages, inputs) {
+        return applyTemplateToInitialMessages(initialMessages, inputs);
+    }
+    /**
+     * Checks if the agent should terminate due to exceeding configured limits.
+     *
+     * @param startTime The timestamp (ms) when execution started.
+     * @param turnCounter The current turn number.
+     * @param recoveryDeadlineMs If in a recovery turn, the absolute deadline (ms)
+     *   that overrides normal max_time_minutes. Pass `undefined` when not recovering.
+     * @returns The reason for termination, or `null` if execution can continue.
+     */
+    checkTermination(startTime, turnCounter, recoveryDeadlineMs) {
+        return checkAgentTermination(this.definition.runConfig, startTime, turnCounter, recoveryDeadlineMs);
+    }
+    /** Emits an activity event to the configured callback. */
+    emitActivity(type, data) {
+        if (this.onActivity) {
+            const event = {
+                isSubagentActivityEvent: true,
+                agentName: this.definition.name,
+                type,
+                data,
+            };
+            this.onActivity(event);
+        }
+    }
+}
+//# sourceMappingURL=executor.js.map