@openai/agents-core 0.11.8 → 0.12.1

package/dist/runner/toolExecution.mjs

@@ -6,12 +6,12 @@ import { RunHandoffCallItem, RunHandoffOutputItem, RunMessageOutputItem, RunTool
 import { assistant } from "../helpers/message.mjs";
 import logger from "../logger.mjs";
 import { FUNCTION_TOOL_PARSED_INPUT_CALLBACK, invokeFunctionTool, resolveComputer, } from "../tool.mjs";
-import { encodeUint8ArrayToBase64 } from "../utils/base64.mjs";
 import { toSmartString } from "../utils/smartString.mjs";
 import { isZodObject } from "../utils/index.mjs";
 import { withFunctionSpan, withHandoffSpan } from "../tracing/createSpans.mjs";
 import { getCurrentTrace } from "../tracing/context.mjs";
 import { getFunctionToolQualifiedName, matchesFunctionToolName, } from "../toolIdentity.mjs";
+import { convertStructuredToolOutputToInputItem, normalizeStructuredToolOutputs, } from "./toolOutputNormalization.mjs";
 import { runToolInputGuardrails, runToolOutputGuardrails, } from "../utils/toolGuardrails.mjs";
 import { maybeExtractToolOutputCustomData } from "../utils/customData.mjs";
 import { resolveApprovalRejectionMessage, TOOL_APPROVAL_REJECTION_MESSAGE, } from "./approvalRejection.mjs";
@@ -225,10 +225,6 @@ async function buildApprovalRejectionResult(deps, toolRun) {
 async function handleFunctionApproval(deps, toolRun, parsedArgs) {
     const { agent, state } = deps;
     const toolName = getFunctionToolIdentity(toolRun);
-    const needsApproval = await toolRun.tool.needsApproval(state._context, parsedArgs, toolRun.toolCall.callId);
-    if (!needsApproval) {
-        return 'approved';
-    }
     const approval = state._context.isToolApproved({
         toolName,
         callId: toolRun.toolCall.callId,
@@ -237,24 +233,28 @@ async function handleFunctionApproval(deps, toolRun, parsedArgs) {
         state.clearPendingAgentToolRun(toolName, toolRun.toolCall.callId);
         return await buildApprovalRejectionResult(deps, toolRun);
     }
-    if (approval !== true) {
-        if (shouldRunPreApprovalInputGuardrails(deps)) {
-            const inputGuardrailResult = await runFunctionToolInputGuardrails({
-                guardrails: toolRun.tool.inputGuardrails,
-                context: state._context,
-                agent,
-                toolCall: toolRun.toolCall,
-                onResult: (result) => {
-                    state._toolInputGuardrailResults.push(result);
-                },
-            });
-            if (inputGuardrailResult.type === 'reject') {
-                return buildInputGuardrailRejectionResult(deps, toolRun, inputGuardrailResult.message);
-            }
+    if (approval === true) {
+        return 'approved';
+    }
+    const needsApproval = await toolRun.tool.needsApproval(state._context, parsedArgs, toolRun.toolCall.callId);
+    if (!needsApproval) {
+        return 'approved';
+    }
+    if (shouldRunPreApprovalInputGuardrails(deps)) {
+        const inputGuardrailResult = await runFunctionToolInputGuardrails({
+            guardrails: toolRun.tool.inputGuardrails,
+            context: state._context,
+            agent,
+            toolCall: toolRun.toolCall,
+            onResult: (result) => {
+                state._toolInputGuardrailResults.push(result);
+            },
+        });
+        if (inputGuardrailResult.type === 'reject') {
+            return buildInputGuardrailRejectionResult(deps, toolRun, inputGuardrailResult.message);
         }
-        return buildApprovalRequestResult(deps, toolRun);
     }
-    return 'approved';
+    return buildApprovalRequestResult(deps, toolRun);
 }
 function buildInputGuardrailRejectionResult(deps, toolRun, message) {
     return {
@@ -446,7 +446,17 @@ async function withToolFunctionSpan(runner, toolName, fn) {
 }
 async function resolveToolApproval(options) {
     const { runContext, toolName, callId, approvalItem, needsApproval, onApproval, } = options;
-    if (!needsApproval) {
+    const existingApproval = runContext.isToolApproved({
+        toolName,
+        callId,
+    });
+    if (existingApproval === true) {
+        return 'approved';
+    }
+    if (existingApproval === false) {
+        return 'rejected';
+    }
+    if (!(await needsApproval())) {
         return 'approved';
     }
     if (onApproval) {
@@ -529,7 +539,7 @@ export async function executeShellActions(agent, actions, runner, runContext, cu
             toolName: shellTool.name,
             callId: toolCallKey,
             approvalItem,
-            needsApproval: await shellTool.needsApproval(runContext, toolCall.action, toolCallKey),
+            needsApproval: () => shellTool.needsApproval(runContext, toolCall.action, toolCallKey),
             onApproval: shellTool.onApproval,
             buildRejectionItem: async () => {
                 const response = await resolveApprovalRejectionMessage({
@@ -629,7 +639,7 @@ export async function executeApplyPatchOperations(agent, actions, runner, runCon
             toolName: applyPatchTool.name,
             callId: toolCallKey,
             approvalItem,
-            needsApproval: await applyPatchTool.needsApproval(runContext, toolCall.operation, toolCallKey),
+            needsApproval: () => applyPatchTool.needsApproval(runContext, toolCall.operation, toolCallKey),
             onApproval: applyPatchTool.onApproval,
             buildRejectionItem: async () => {
                 const response = await resolveApprovalRejectionMessage({
@@ -749,17 +759,16 @@ export async function executeComputerActions(agent, actions, runner, runContext,
         const approvalItem = new RunToolApprovalItem(toolCall, agent, computerTool.name);
         const needsApprovalCandidate = computerTool
             .needsApproval;
-        const needsApproval = typeof needsApprovalCandidate === 'function'
-            ? (await Promise.all(computerActions.map((computerAction) => needsApprovalCandidate(runContext, computerAction, toolCall.callId)))).some(Boolean)
-            : typeof needsApprovalCandidate === 'boolean'
-                ? needsApprovalCandidate
-                : false;
         const approvalDecision = await handleToolApprovalDecision({
             runContext,
             toolName: computerTool.name,
             callId: toolCall.callId,
             approvalItem,
-            needsApproval,
+            needsApproval: async () => typeof needsApprovalCandidate === 'function'
+                ? (await Promise.all(computerActions.map((computerAction) => needsApprovalCandidate(runContext, computerAction, toolCall.callId)))).some(Boolean)
+                : typeof needsApprovalCandidate === 'boolean'
+                    ? needsApprovalCandidate
+                    : false,
             buildRejectionItem: async () => {
                 const rejectionMessage = await getRejectionMessage();
                 const rejectionOutput = {
@@ -876,6 +885,14 @@ export async function executeHandoffCalls(agent, originalInput, preStepItems, ne
     const actualHandoff = runHandoffs[0];
     return withHandoffSpan(async (handoffSpan) => {
         const handoff = actualHandoff.handoff;
+        const inputFilter = handoff.inputFilter ?? runner.config.handoffInputFilter;
+        if (inputFilter != null && typeof inputFilter !== 'function') {
+            throw Object.assign(new UserError('Invalid handoff input filter: not callable'), {
+                data: {
+                    details: 'not callable',
+                },
+            });
+        }
         const newAgent = await handoff.onInvokeHandoff(runContext, actualHandoff.toolCall.arguments);
         handoffSpan.spanData.to_agent = newAgent.name;
         if (runHandoffs.length > 1) {
@@ -890,17 +907,8 @@ export async function executeHandoffCalls(agent, originalInput, preStepItems, ne
         newStepItems.push(new RunHandoffOutputItem(getToolCallOutputItem(actualHandoff.toolCall, getTransferMessage(newAgent)), agent, newAgent));
         runner.emit('agent_handoff', runContext, agent, newAgent);
         agent.emit('agent_handoff', runContext, newAgent);
-        const inputFilter = handoff.inputFilter ?? runner.config.handoffInputFilter;
-        if (inputFilter) {
+        if (inputFilter != null) {
             logger.debug('Filtering inputs for handoff');
-            if (typeof inputFilter !== 'function') {
-                handoffSpan.setError({
-                    message: 'Invalid input filter',
-                    data: {
-                        details: 'not callable',
-                    },
-                });
-            }
             const handoffInputData = {
                 inputHistory: Array.isArray(originalInput)
                     ? [...originalInput]
@@ -1006,315 +1014,6 @@ export async function checkForFinalOutputFromTools(agent, toolResults, state, ad
     }
     throw new UserError(`Invalid toolUseBehavior: ${toolUseBehavior}`, state);
 }
-/**
- * Accepts whatever the tool returned and attempts to coerce it into the structured protocol
- * shapes we expose to downstream model adapters (input_text/input_image/input_file). Tools are
- * allowed to return either a single structured object or an array of them; anything else falls
- * back to the legacy string pipeline.
- */
-function normalizeStructuredToolOutputs(output) {
-    if (Array.isArray(output)) {
-        const structured = [];
-        for (const item of output) {
-            const normalized = normalizeStructuredToolOutput(item);
-            if (!normalized) {
-                return null;
-            }
-            structured.push(normalized);
-        }
-        return structured;
-    }
-    const normalized = normalizeStructuredToolOutput(output);
-    return normalized ? [normalized] : null;
-}
-/**
- * Best-effort normalization of a single tool output item. If the object already matches the
- * protocol shape we simply cast it; otherwise we copy the recognised fields into the canonical
- * structure. Returning null lets the caller know we should revert to plain-string handling.
- */
-function normalizeStructuredToolOutput(value) {
-    if (!isRecord(value)) {
-        return null;
-    }
-    const type = value.type;
-    if (type === 'text' && typeof value.text === 'string') {
-        const output = { type: 'text', text: value.text };
-        if (isRecord(value.providerData)) {
-            output.providerData = value.providerData;
-        }
-        return output;
-    }
-    if (type === 'image') {
-        const output = { type: 'image' };
-        let imageString;
-        let imageFileId;
-        const fallbackImageMediaType = getImageInlineMediaType(value);
-        const imageField = value.image;
-        if (typeof imageField === 'string' && imageField.length > 0) {
-            imageString = imageField;
-        }
-        else if (isRecord(imageField)) {
-            const imageObj = imageField;
-            const inlineMediaType = getImageInlineMediaType(imageObj) ?? fallbackImageMediaType;
-            if (isNonEmptyString(imageObj.url)) {
-                imageString = imageObj.url;
-            }
-            else if (isNonEmptyString(imageObj.data)) {
-                imageString = toInlineImageString(imageObj.data, inlineMediaType);
-            }
-            else if (imageObj.data instanceof Uint8Array &&
-                imageObj.data.length > 0) {
-                imageString = toInlineImageString(imageObj.data, inlineMediaType);
-            }
-            if (!imageString) {
-                const candidateId = (isNonEmptyString(imageObj.fileId) && imageObj.fileId) ||
-                    (isNonEmptyString(imageObj.id) && imageObj.id) ||
-                    undefined;
-                if (candidateId) {
-                    imageFileId = candidateId;
-                }
-            }
-        }
-        if (!imageString &&
-            typeof value.imageUrl === 'string' &&
-            value.imageUrl.length > 0) {
-            imageString = value.imageUrl;
-        }
-        if (!imageFileId &&
-            typeof value.fileId === 'string' &&
-            value.fileId.length > 0) {
-            imageFileId = value.fileId;
-        }
-        if (!imageString &&
-            typeof value.data === 'string' &&
-            value.data.length > 0) {
-            imageString = fallbackImageMediaType
-                ? toInlineImageString(value.data, fallbackImageMediaType)
-                : value.data;
-        }
-        else if (!imageString &&
-            value.data instanceof Uint8Array &&
-            value.data.length > 0) {
-            imageString = toInlineImageString(value.data, fallbackImageMediaType);
-        }
-        if (typeof value.detail === 'string' && value.detail.length > 0) {
-            output.detail = value.detail;
-        }
-        if (imageString) {
-            output.image = imageString;
-        }
-        else if (imageFileId) {
-            output.image = { fileId: imageFileId };
-        }
-        else {
-            return null;
-        }
-        if (isRecord(value.providerData)) {
-            output.providerData = value.providerData;
-        }
-        return output;
-    }
-    if (type === 'file') {
-        const fileValue = normalizeFileValue(value);
-        if (!fileValue) {
-            return null;
-        }
-        const output = { type: 'file', file: fileValue };
-        if (isRecord(value.providerData)) {
-            output.providerData = value.providerData;
-        }
-        return output;
-    }
-    return null;
-}
-/**
- * Translates the normalized tool output into the protocol `input_*` items. This is the last hop
- * before we hand the data to model-specific adapters, so we generate the exact schema expected by
- * the protocol definitions.
- */
-function convertStructuredToolOutputToInputItem(output) {
-    if (output.type === 'text') {
-        const result = {
-            type: 'input_text',
-            text: output.text,
-        };
-        if (output.providerData) {
-            result.providerData = output.providerData;
-        }
-        return result;
-    }
-    if (output.type === 'image') {
-        const result = { type: 'input_image' };
-        if (typeof output.detail === 'string' && output.detail.length > 0) {
-            result.detail = output.detail;
-        }
-        if (typeof output.image === 'string' && output.image.length > 0) {
-            result.image = output.image;
-        }
-        else if (isRecord(output.image)) {
-            const imageObj = output.image;
-            const inlineMediaType = getImageInlineMediaType(imageObj);
-            if (isNonEmptyString(imageObj.url)) {
-                result.image = imageObj.url;
-            }
-            else if (isNonEmptyString(imageObj.data)) {
-                result.image =
-                    inlineMediaType && !imageObj.data.startsWith('data:')
-                        ? asDataUrl(imageObj.data, inlineMediaType)
-                        : imageObj.data;
-            }
-            else if (imageObj.data instanceof Uint8Array &&
-                imageObj.data.length > 0) {
-                const base64 = encodeUint8ArrayToBase64(imageObj.data);
-                result.image = asDataUrl(base64, inlineMediaType);
-            }
-            else {
-                const referencedId = (isNonEmptyString(imageObj.fileId) && imageObj.fileId) ||
-                    (isNonEmptyString(imageObj.id) && imageObj.id) ||
-                    undefined;
-                if (referencedId) {
-                    result.image = { id: referencedId };
-                }
-            }
-        }
-        if (output.providerData) {
-            result.providerData = output.providerData;
-        }
-        return result;
-    }
-    if (output.type === 'file') {
-        const result = { type: 'input_file' };
-        const fileValue = output.file;
-        if (typeof fileValue === 'string') {
-            result.file = fileValue;
-        }
-        else if (fileValue && typeof fileValue === 'object') {
-            const record = fileValue;
-            if ('data' in record && record.data) {
-                const mediaType = record.mediaType ?? 'text/plain';
-                if (typeof record.data === 'string') {
-                    result.file = asDataUrl(record.data, mediaType);
-                }
-                else {
-                    const base64 = encodeUint8ArrayToBase64(record.data);
-                    result.file = asDataUrl(base64, mediaType);
-                }
-            }
-            else if (typeof record.url === 'string' && record.url.length > 0) {
-                result.file = { url: record.url };
-            }
-            else {
-                const referencedId = (typeof record.id === 'string' &&
-                    record.id.length > 0 &&
-                    record.id) ||
-                    (typeof record.fileId === 'string' && record.fileId.length > 0
-                        ? record.fileId
-                        : undefined);
-                if (referencedId) {
-                    result.file = { id: referencedId };
-                }
-            }
-            if (typeof record.filename === 'string' && record.filename.length > 0) {
-                result.filename = record.filename;
-            }
-        }
-        if (output.providerData) {
-            result.providerData = output.providerData;
-        }
-        return result;
-    }
-    const exhaustiveCheck = output;
-    return exhaustiveCheck;
-}
-function normalizeFileValue(value) {
-    const directFile = value.file;
-    if (typeof directFile === 'string' && directFile.length > 0) {
-        return directFile;
-    }
-    const normalizedObject = normalizeFileObjectCandidate(directFile);
-    if (normalizedObject) {
-        return normalizedObject;
-    }
-    const legacyValue = normalizeLegacyFileValue(value);
-    if (legacyValue) {
-        return legacyValue;
-    }
-    return null;
-}
-function normalizeFileObjectCandidate(value) {
-    if (!isRecord(value)) {
-        return null;
-    }
-    if ('data' in value && value.data !== undefined) {
-        const dataValue = value.data;
-        const hasStringData = typeof dataValue === 'string' && dataValue.length > 0;
-        const hasBinaryData = dataValue instanceof Uint8Array && dataValue.length > 0;
-        if (!hasStringData && !hasBinaryData) {
-            return null;
-        }
-        if (!isNonEmptyString(value.mediaType) ||
-            !isNonEmptyString(value.filename)) {
-            return null;
-        }
-        return {
-            data: typeof dataValue === 'string' ? dataValue : new Uint8Array(dataValue),
-            mediaType: value.mediaType,
-            filename: value.filename,
-        };
-    }
-    if (isNonEmptyString(value.url)) {
-        const result = { url: value.url };
-        if (isNonEmptyString(value.filename)) {
-            result.filename = value.filename;
-        }
-        return result;
-    }
-    const referencedId = (isNonEmptyString(value.id) && value.id) ||
-        (isNonEmptyString(value.fileId) && value.fileId);
-    if (referencedId) {
-        const result = { id: referencedId };
-        if (isNonEmptyString(value.filename)) {
-            result.filename = value.filename;
-        }
-        return result;
-    }
-    return null;
-}
-function normalizeLegacyFileValue(value) {
-    const filename = typeof value.filename === 'string' && value.filename.length > 0
-        ? value.filename
-        : undefined;
-    const mediaType = typeof value.mediaType === 'string' && value.mediaType.length > 0
-        ? value.mediaType
-        : undefined;
-    if (typeof value.fileData === 'string' && value.fileData.length > 0) {
-        if (!mediaType || !filename) {
-            return null;
-        }
-        return { data: value.fileData, mediaType, filename };
-    }
-    if (value.fileData instanceof Uint8Array && value.fileData.length > 0) {
-        if (!mediaType || !filename) {
-            return null;
-        }
-        return { data: new Uint8Array(value.fileData), mediaType, filename };
-    }
-    if (typeof value.fileUrl === 'string' && value.fileUrl.length > 0) {
-        const result = { url: value.fileUrl };
-        if (filename) {
-            result.filename = filename;
-        }
-        return result;
-    }
-    if (typeof value.fileId === 'string' && value.fileId.length > 0) {
-        const result = { id: value.fileId };
-        if (filename) {
-            result.filename = filename;
-        }
-        return result;
-    }
-    return null;
-}
 function normalizeSafetyChecks(checks) {
     if (!Array.isArray(checks)) {
         return undefined;
@@ -1392,26 +1091,4 @@ function isRecord(value) {
 function isNonEmptyString(value) {
     return typeof value === 'string' && value.length > 0;
 }
-function getImageInlineMediaType(value) {
-    if (isNonEmptyString(value.mediaType)) {
-        return value.mediaType;
-    }
-    if (isNonEmptyString(value.mimeType)) {
-        return value.mimeType;
-    }
-    return undefined;
-}
-function toInlineImageString(data, mediaType) {
-    if (typeof data === 'string') {
-        if (mediaType && !data.startsWith('data:')) {
-            return asDataUrl(data, mediaType);
-        }
-        return data;
-    }
-    const base64 = encodeUint8ArrayToBase64(data);
-    return asDataUrl(base64, mediaType);
-}
-function asDataUrl(base64, mediaType) {
-    return mediaType ? `data:${mediaType};base64,${base64}` : base64;
-}
 //# sourceMappingURL=toolExecution.mjs.map