maka-agent 0.1.0-beta.1 → 0.2.0-dev.3.20260830

package/node_modules/@openai/agents-core/dist/runner/toolExecution.js

@@ -45,13 +45,14 @@ const agentToolRunConfig_1 = require("../agentToolRunConfig.js");
 const agentToolRunResults_1 = require("../agentToolRunResults.js");
 const errors_1 = require("../errors.js");
 const toolInputError_1 = require("../toolInputError.js");
+const toolOutputError_1 = require("../toolOutputError.js");
 const handoff_1 = require("../handoff.js");
 const items_1 = require("../items.js");
 const message_1 = require("../helpers/message.js");
 const logger_1 = __importStar(require("../logger.js"));
 const tool_1 = require("../tool.js");
 const abortSignals_1 = require("../utils/abortSignals.js");
-const utils_1 = require("../utils/index.js");
+const standardSchema_1 = require("../utils/standardSchema.js");
 const smartString_1 = require("../utils/smartString.js");
 const createSpans_1 = require("../tracing/createSpans.js");
 const context_1 = require("../tracing/context.js");
@@ -65,6 +66,7 @@ const usageTracking_1 = require("./usageTracking.js");
 const invocationContext_1 = require("./invocationContext.js");
 const streamReconciliation_1 = require("./streamReconciliation.js");
 const siblingCancellation_1 = require("./siblingCancellation.js");
+const items_2 = require("./items.js");
 const REDACTED_TOOL_ERROR_MESSAGE = 'Tool execution failed. Error details are redacted.';
 function getFunctionToolIdentity(toolRun) {
     return (0, toolIdentity_1.getFunctionToolQualifiedName)(toolRun.tool) ?? toolRun.tool.name;
@@ -150,7 +152,7 @@ function getToolCallOutputItem(toolCall, output, options) {
             textOutput = serializedOutput;
         }
         catch (error) {
-            throw new errors_1.InvalidToolOutputError(`Function tool '${toolCall.name}' outputSchema requires a JSON-serializable output.`, undefined, error, { output });
+            throw (0, toolOutputError_1.createInvalidToolOutputError)(`Function tool '${toolCall.name}' outputSchema requires a JSON-serializable output.`, error, { output });
         }
     }
     else {
@@ -177,6 +179,19 @@ function getToolCallOutputItem(toolCall, output, options) {
  * the `RunItem` instances that should be appended to history.
  */
 async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErrorFormatter, agentToolParentRunConfig, signal, onFatalFailure) {
+    const startedInvalidInputFailures = [];
+    const startedInvalidOutputFailures = [];
+    const trackInvalidOutputFailure = (failure) => {
+        if (!startedInvalidOutputFailures.includes(failure)) {
+            startedInvalidOutputFailures.push(failure);
+        }
+    };
+    const trackInvalidOutputError = (error) => {
+        const failure = (0, toolOutputError_1.getInvalidToolOutputFailure)(error);
+        if (failure) {
+            trackInvalidOutputFailure(failure);
+        }
+    };
     const deps = {
         agent,
         runner,
@@ -184,8 +199,8 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
         toolErrorFormatter,
         agentToolParentRunConfig,
         signal,
+        onInvalidOutputFailure: trackInvalidOutputFailure,
     };
-    const startedInvalidInputFailures = [];
     const executeToolRun = async (toolRun, executionSignal = signal) => {
         const executionDeps = executionSignal === deps.signal
             ? deps
@@ -206,8 +221,12 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
                     details: { toolCall: toolRun.toolCall },
                 },
                 disposition: parseResult.preparedInput?.disposition,
+                fatal: (0, standardSchema_1.isAsyncStandardSchemaValidationError)(parseResult.error),
             });
             startedInvalidInputFailures.push(failure);
+            if (failure.fatal) {
+                throw failure.error;
+            }
         }
         const dynamicApprovalPolicy = (0, tool_1.hasDynamicFunctionToolApprovalPolicy)(toolRun.tool);
         // Handle parse errors gracefully instead of crashing.
@@ -221,9 +240,10 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
                     return buildFunctionCancellationResult(executionDeps, toolRun);
                 }
                 try {
-                    return await runApprovedFunctionTool(executionDeps, toolRun, parseResult.approvalArgs, parseResult.preparedInput, failure);
+                    return await runApprovedFunctionTool(executionDeps, toolRun, parseResult.approvalArgs, parseResult.preparedInput, failure, trackInvalidOutputFailure);
                 }
                 catch (error) {
+                    trackInvalidOutputError(error);
                     if (executionSignal?.aborted &&
                         (error === executionSignal.reason || (0, abortSignals_1.isAbortError)(error))) {
                         return buildFunctionCancellationResult(executionDeps, toolRun);
@@ -251,9 +271,10 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
             return buildFunctionCancellationResult(executionDeps, toolRun);
         }
         try {
-            return await runApprovedFunctionTool(executionDeps, toolRun, parseResult.approvalArgs, parseResult.preparedInput);
+            return await runApprovedFunctionTool(executionDeps, toolRun, parseResult.approvalArgs, parseResult.preparedInput, undefined, trackInvalidOutputFailure);
         }
         catch (error) {
+            trackInvalidOutputError(error);
             if (executionSignal?.aborted &&
                 (error === executionSignal.reason || (0, abortSignals_1.isAbortError)(error))) {
                 return buildFunctionCancellationResult(executionDeps, toolRun);
@@ -267,11 +288,17 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
     }
     catch (e) {
         const redactInvalidInputFailure = startedInvalidInputFailures.some((failure) => (0, toolInputError_1.refreshInvalidToolInputFailure)(failure));
-        if (redactInvalidInputFailure) {
+        const invalidOutputFailure = (0, toolOutputError_1.getInvalidToolOutputFailure)(e);
+        const redactStartedInvalidOutputFailure = startedInvalidOutputFailures.some((failure) => (0, toolOutputError_1.refreshInvalidToolOutputFailure)(failure));
+        const redactSurfacedInvalidOutputFailure = invalidOutputFailure
+            ? (0, toolOutputError_1.refreshInvalidToolOutputFailure)(invalidOutputFailure)
+            : (0, toolOutputError_1.isRedactedInvalidToolOutputError)(e);
+        const redactInvalidOutputFailure = redactStartedInvalidOutputFailure || redactSurfacedInvalidOutputFailure;
+        if (redactInvalidInputFailure || redactInvalidOutputFailure) {
             (0, errors_1.clearToolErrorState)(e, state);
         }
         if ((0, errors_1.isToolTimeoutError)(e)) {
-            if (redactInvalidInputFailure) {
+            if (redactInvalidInputFailure || redactInvalidOutputFailure) {
                 e.state = undefined;
             }
             else {
@@ -279,8 +306,10 @@ async function executeFunctionToolCalls(agent, toolRuns, runner, state, toolErro
             }
             throw e;
         }
-        const surfacedError = e;
-        throw new errors_1.ToolCallError(`Failed to run function tools: ${surfacedError}`, surfacedError, redactInvalidInputFailure || (0, toolInputError_1.isRedactedInvalidToolInputError)(e)
+        const surfacedError = (invalidOutputFailure?.error ?? e);
+        throw new errors_1.ToolCallError(`Failed to run function tools: ${surfacedError}`, surfacedError, redactInvalidInputFailure ||
+            (0, toolInputError_1.isRedactedInvalidToolInputError)(e) ||
+            redactInvalidOutputFailure
             ? undefined
             : state);
     }
@@ -327,12 +356,7 @@ function parseToolArguments(toolRun) {
     try {
         let approvalArgs = toolRun.toolCall.arguments;
         if (toolRun.tool.parameters) {
-            if ((0, utils_1.isZodObject)(toolRun.tool.parameters)) {
-                approvalArgs = toolRun.tool.parameters.parse(approvalArgs);
-            }
-            else {
-                approvalArgs = JSON.parse(approvalArgs);
-            }
+            approvalArgs = JSON.parse(toolRun.toolCall.arguments);
         }
         const preparedInput = (0, tool_1.prepareFunctionToolInput)(toolRun.tool, toolRun.toolCall.arguments);
         if (preparedInput && !preparedInput.result.success) {
@@ -343,6 +367,31 @@ function parseToolArguments(toolRun) {
                 preparedInput,
             };
         }
+        if (preparedInput?.validationMode === 'standard') {
+            approvalArgs = preparedInput?.result.success
+                ? preparedInput.result.value
+                : approvalArgs;
+            if (!(0, tool_1.hasDynamicFunctionToolApprovalPolicy)(toolRun.tool)) {
+                return { success: true, approvalArgs, preparedInput };
+            }
+            const executionPreparedInput = (0, tool_1.prepareFunctionToolInput)(toolRun.tool, toolRun.toolCall.arguments);
+            if (!executionPreparedInput) {
+                throw new Error('Standard Schema input could not be prepared for execution.');
+            }
+            if (!executionPreparedInput.result.success) {
+                return {
+                    success: false,
+                    error: executionPreparedInput.result.error,
+                    approvalArgs,
+                    preparedInput: executionPreparedInput,
+                };
+            }
+            return {
+                success: true,
+                approvalArgs,
+                preparedInput: executionPreparedInput,
+            };
+        }
         return { success: true, approvalArgs, preparedInput };
     }
     catch (error) {
@@ -363,13 +412,24 @@ function buildApprovalRequestResult(deps, toolRun) {
     };
 }
 function buildFunctionFailureResult(deps, toolRun, output) {
+    let rawItem;
+    try {
+        rawItem = getToolCallOutputItem(toolRun.toolCall, output, {
+            outputSchema: toolRun.tool.outputSchema,
+        });
+    }
+    catch (error) {
+        const invalidOutputFailure = (0, toolOutputError_1.getInvalidToolOutputFailure)(error);
+        if (invalidOutputFailure) {
+            deps.onInvalidOutputFailure?.(invalidOutputFailure);
+        }
+        throw error;
+    }
     return {
         type: 'function_output',
         tool: toolRun.tool,
         output,
-        runItem: new items_1.RunToolCallOutputItem(getToolCallOutputItem(toolRun.toolCall, output, {
-            outputSchema: toolRun.tool.outputSchema,
-        }), deps.agent, output),
+        runItem: new items_1.RunToolCallOutputItem(rawItem, deps.agent, output),
     };
 }
 function buildFunctionCancellationResult(deps, toolRun) {
@@ -408,12 +468,22 @@ async function resolveFunctionFailureOutput(deps, toolRun, error, legacyOutput,
             (0, toolInputError_1.refreshInvalidToolInputFailure)(redactionBoundary.failure)) {
             throw redactionBoundary.failure.error;
         }
-        const validatedOutput = (0, tool_1.validateFunctionToolOutput)({
-            tool: toolRun.tool,
-            output,
-            runContext: deps.state._context,
-            details,
-        });
+        let validatedOutput;
+        try {
+            validatedOutput = (0, tool_1.validateFunctionToolOutput)({
+                tool: toolRun.tool,
+                output,
+                runContext: deps.state._context,
+                details,
+            });
+        }
+        catch (error) {
+            const invalidOutputFailure = (0, toolOutputError_1.getInvalidToolOutputFailure)(error);
+            if (invalidOutputFailure) {
+                deps.onInvalidOutputFailure?.(invalidOutputFailure);
+            }
+            throw error;
+        }
         if (redactionBoundary &&
             !redactedBeforeCallback &&
             (0, toolInputError_1.refreshInvalidToolInputFailure)(redactionBoundary.failure)) {
@@ -631,7 +701,7 @@ async function runFunctionToolInputGuardrails({ guardrails, context, agent, tool
         onResult,
     });
 }
-async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInput, invalidInputFailure) {
+async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInput, invalidInputFailure, onInvalidOutputFailure) {
     const { agent, runner, state, agentToolParentRunConfig, signal } = deps;
     const toolName = getFunctionToolIdentity(toolRun);
     const stateKeys = getFunctionToolPendingStateKeys(toolRun);
@@ -660,6 +730,7 @@ async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInpu
         let toolStarted = false;
         let invocationPending = false;
         let cancellationFinalizationAttempted = false;
+        let committedOutputOnFailure = false;
         const buildSiblingCancellationResult = () => {
             if (toolStarted) {
                 toolStarted = false;
@@ -762,6 +833,7 @@ async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInpu
                     [tool_1.FUNCTION_TOOL_PARSED_INPUT_CALLBACK]: (input) => {
                         executedInput = cloneForCustomDataContext(input);
                     },
+                    [tool_1.FUNCTION_TOOL_INVALID_OUTPUT_FAILURE_CALLBACK]: onInvalidOutputFailure,
                 };
                 if (preparedInput) {
                     (0, tool_1.setFunctionToolPreparedInput)(toolDetails, preparedInput);
@@ -862,15 +934,30 @@ async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInpu
             if (customDataFailed) {
                 throw customDataError;
             }
+            const committedRunItem = new items_1.RunToolCallOutputItem(rawItem, agent, toolOutput, customData, executionStatus);
             const redactedBeforeToolEnd = refreshRedaction();
             try {
                 emitFunctionToolEnd(runner, state._context, agent, toolRun.tool, stringResult, toolRun.toolCall, refreshRedaction);
+                throwIfRedactionPromoted(redactedBeforeToolEnd);
             }
             catch (hookError) {
-                throwIfRedactionPromoted(redactedBeforeToolEnd);
+                if (state._currentStep?.type !== 'next_step_interruption' ||
+                    state._currentStep.data?.responseAccepted !== true) {
+                    throwIfRedactionPromoted(redactedBeforeToolEnd);
+                    throw hookError;
+                }
+                const callRunItem = new items_1.RunToolCallItem(toolRun.toolCall, agent);
+                const checkpointItems = state._generatedItems.some((item) => item instanceof items_1.RunToolCallItem &&
+                    item.agent === agent &&
+                    item.rawItem.type === 'function_call' &&
+                    item.rawItem.callId === toolRun.toolCall.callId)
+                    ? [committedRunItem]
+                    : [callRunItem, committedRunItem];
+                state._generatedItems.push(...checkpointItems);
+                state._commitToolInvocations(checkpointItems);
+                committedOutputOnFailure = true;
                 throw hookError;
             }
-            throwIfRedactionPromoted(redactedBeforeToolEnd);
             if (span && runner.config.traceIncludeSensitiveData) {
                 span.spanData.output = stringResult;
             }
@@ -878,7 +965,7 @@ async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInpu
                 type: 'function_output',
                 tool: toolRun.tool,
                 output: toolOutput,
-                runItem: new items_1.RunToolCallOutputItem(rawItem, agent, toolOutput, customData, executionStatus),
+                runItem: committedRunItem,
             };
             const nestedRunResult = (0, agentToolRunResults_1.consumeAgentToolRunResult)(toolRun.toolCall);
             if (nestedRunResult) {
@@ -899,6 +986,13 @@ async function runApprovedFunctionTool(deps, toolRun, approvalArgs, preparedInpu
             return functionResult;
         }
         catch (error) {
+            const invalidOutputFailure = (0, toolOutputError_1.getInvalidToolOutputFailure)(error);
+            if (invalidOutputFailure) {
+                onInvalidOutputFailure?.(invalidOutputFailure);
+            }
+            if (committedOutputOnFailure) {
+                throw error;
+            }
             if (cancellationFinalizationAttempted) {
                 throw error;
             }
@@ -1022,12 +1116,8 @@ async function withRunStateToolFunctionSpan(deps, toolName, fn) {
     return withToolFunctionSpan(deps.runner, toolName, fn, (0, invocationContext_1.getRunStateTurnSpanParent)(deps.state) ?? deps.state._currentAgentSpan);
 }
 async function resolveToolApproval(options) {
-    const { runContext, toolName, callId, approvalItem, needsApproval, onApproval, isCancelled, } = options;
-    const existingApproval = runContext.isToolApproved({
-        toolName,
-        callId,
-        functionTool: false,
-    });
+    const { runContext, toolName, approvalItem, needsApproval, onApproval, isCancelled, } = options;
+    const existingApproval = runContext._resolveToolInvocationApproval(approvalItem.agent, toolName, approvalItem.rawItem);
     if (existingApproval === true) {
         return 'approved';
     }
@@ -1065,11 +1155,7 @@ async function resolveToolApproval(options) {
             runContext.rejectTool(approvalItem, reason === undefined ? undefined : { message: reason });
         }
     }
-    const approval = runContext.isToolApproved({
-        toolName,
-        callId,
-        functionTool: false,
-    });
+    const approval = runContext._resolveToolInvocationApproval(approvalItem.agent, toolName, approvalItem.rawItem);
     if (approval === true) {
         return 'approved';
     }
@@ -1079,11 +1165,10 @@ async function resolveToolApproval(options) {
     return 'pending';
 }
 async function handleToolApprovalDecision(options) {
-    const { runContext, toolName, callId, approvalItem, needsApproval, onApproval, buildRejectionItem, isCancelled, buildCancellationItem, } = options;
+    const { runContext, toolName, approvalItem, needsApproval, onApproval, buildRejectionItem, isCancelled, buildCancellationItem, } = options;
     const approvalState = await resolveToolApproval({
         runContext,
         toolName,
-        callId,
         approvalItem,
         needsApproval,
         onApproval,
@@ -1171,7 +1256,6 @@ async function executeShellActions(agent, actions, runner, runContext, customLog
         const approvalDecision = await handleToolApprovalDecision({
             runContext,
             toolName: shellTool.name,
-            callId: toolCallKey,
             approvalItem,
             needsApproval: () => shellTool.needsApproval(runContext, toolCall.action, toolCallKey),
             onApproval: shellTool.onApproval,
@@ -1273,7 +1357,6 @@ async function executeApplyPatchOperations(agent, actions, runner, runContext, c
         const approvalDecision = await handleToolApprovalDecision({
             runContext,
             toolName: applyPatchTool.name,
-            callId: toolCallKey,
             approvalItem,
             needsApproval: () => applyPatchTool.needsApproval(runContext, toolCall.operation, toolCallKey),
             onApproval: applyPatchTool.onApproval,
@@ -1404,7 +1487,6 @@ async function executeComputerActions(agent, actions, runner, runContext, custom
         const approvalDecision = await handleToolApprovalDecision({
             runContext,
             toolName: computerTool.name,
-            callId: toolCall.callId,
             approvalItem,
             needsApproval: async () => {
                 if (typeof needsApprovalCandidate !== 'function') {
@@ -1603,7 +1685,7 @@ function buildComputerCancellationItem(agent, toolCall) {
  * Drives handoff calls by invoking the downstream agent and capturing any generated items so
  * the current agent can continue with the new context.
  */
-async function executeHandoffCalls(agent, originalInput, preStepItems, newStepItems, newResponse, runHandoffs, runner, runContext, parent) {
+async function executeHandoffCalls(agent, originalInput, preStepItems, newStepItems, newResponse, runHandoffs, runner, runContext, parent, validateHandoffAgent) {
     newStepItems = [...newStepItems];
     if (runHandoffs.length === 0) {
         logger_1.default.warn('Incorrectly called executeHandoffCalls with no handoffs. This should not happen. Moving on.');
@@ -1626,7 +1708,9 @@ async function executeHandoffCalls(agent, originalInput, preStepItems, newStepIt
                 },
             });
         }
+        validateHandoffAgent?.(handoff.agent);
         const newAgent = await handoff.onInvokeHandoff(runContext, actualHandoff.toolCall.arguments);
+        validateHandoffAgent?.(newAgent);
         handoffSpan.spanData.to_agent = newAgent.name;
         if (runHandoffs.length > 1) {
             const requestedAgents = runHandoffs.map((h) => h.handoff.agentName);
@@ -1640,6 +1724,7 @@ async function executeHandoffCalls(agent, originalInput, preStepItems, newStepIt
         newStepItems.push(new items_1.RunHandoffOutputItem(getToolCallOutputItem(actualHandoff.toolCall, (0, handoff_1.getTransferMessage)(newAgent)), agent, newAgent));
         runner.emit('agent_handoff', runContext, agent, newAgent);
         agent.emit('agent_handoff', runContext, newAgent);
+        const toolInvocationCommitItems = [...newStepItems];
         if (inputFilter != null) {
             logger_1.default.debug('Filtering inputs for handoff');
             const handoffInputData = {
@@ -1651,11 +1736,15 @@ async function executeHandoffCalls(agent, originalInput, preStepItems, newStepIt
                 runContext,
             };
             const filtered = inputFilter(handoffInputData);
+            (0, items_2.invalidateOutputItemNormalization)([
+                ...handoffInputData.preHandoffItems,
+                ...handoffInputData.newItems,
+            ]);
             originalInput = filtered.inputHistory;
             preStepItems = filtered.preHandoffItems;
             newStepItems = filtered.newItems;
         }
-        return new steps_1.SingleStepResult(originalInput, newResponse, preStepItems, newStepItems, { type: 'next_step_handoff', newAgent });
+        return new steps_1.SingleStepResult(originalInput, newResponse, preStepItems, newStepItems, { type: 'next_step_handoff', newAgent }, undefined, toolInvocationCommitItems);
     }, {
         data: {
             from_agent: agent.name,