@openai/agents-core
Version:
The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows.
158 lines • 6.65 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.prepareRunErrorFinalOutput = exports.resolveRunErrorHandler = exports.validateRunErrorHandlerFinalOutput = exports.createRunErrorFinalOutputItem = exports.formatRunErrorFinalOutput = exports.attachRunStateToError = void 0;
exports.preserveInvalidFinalOutputRedaction = preserveInvalidFinalOutputRedaction;
exports.invalidateAcceptedResponseReplayEvidence = invalidateAcceptedResponseReplayEvidence;
const errors_1 = require("../errors.js");
const message_1 = require("../helpers/message.js");
const items_1 = require("../items.js");
const logger_1 = __importDefault(require("../logger.js"));
const items_2 = require("./items.js");
const streaming_1 = require("./streaming.js");
const finalOutputError_1 = require("../utils/finalOutputError.js");
async function preserveInvalidFinalOutputRedaction(callback, inheritedRedaction = false) {
const redactFromStart = inheritedRedaction || logger_1.default.dontLogModelData;
try {
return await callback(redactFromStart);
}
catch (error) {
if (redactFromStart || logger_1.default.dontLogModelData) {
throw (0, finalOutputError_1.createRedactedErrorDetailsError)();
}
throw error;
}
}
/**
* Attaches the active run state to errors that need resumable caller context.
*/
const attachRunStateToError = (error, state) => {
if (error instanceof errors_1.ModelTimeoutError) {
error.state ??= state;
return;
}
if (!(error instanceof errors_1.ToolCallError)) {
return;
}
if (error.error instanceof errors_1.ToolInputGuardrailTripwireTriggered ||
error.error instanceof errors_1.ToolOutputGuardrailTripwireTriggered) {
error.error.state ??= state;
}
};
exports.attachRunStateToError = attachRunStateToError;
const buildRunData = (state) => ({
input: state._originalInput,
newItems: state._generatedItems,
history: (0, items_2.getTurnInput)(state._originalInput, state._generatedItems, state._reasoningItemIdPolicy),
output: (0, items_2.getRunOutput)(state._generatedItems, state._reasoningItemIdPolicy),
rawResponses: state._modelResponses,
lastAgent: state._currentAgent,
state,
});
const formatFinalOutput = (agent, finalOutput) => {
if (agent.outputType === 'text') {
return String(finalOutput);
}
return JSON.stringify(finalOutput);
};
const createFinalOutputItem = (agent, outputText) => new items_1.RunMessageOutputItem((0, message_1.assistant)(outputText), agent);
function validateRunErrorFinalOutput(agent, outputText, redactInvalidOutputDetails = false, redactFromStart = false) {
try {
agent.processFinalOutput(outputText);
}
catch (error) {
if (redactInvalidOutputDetails &&
(redactFromStart || logger_1.default.dontLogModelData)) {
throw (0, finalOutputError_1.createRedactedErrorDetailsError)();
}
const message = error instanceof Error ? error.message : String(error);
throw new errors_1.UserError(`Invalid run error handler finalOutput: ${message}`);
}
}
exports.formatRunErrorFinalOutput = formatFinalOutput;
exports.createRunErrorFinalOutputItem = createFinalOutputItem;
exports.validateRunErrorHandlerFinalOutput = validateRunErrorFinalOutput;
function invalidateAcceptedResponseReplayEvidence(state) {
if (state?._currentStep?.type === 'next_step_interruption' &&
state._currentStep.data?.responseAccepted === true) {
state._lastProcessedResponse = undefined;
}
}
const resolveRunErrorHandler = async ({ error, errorKind, errorHandlers, context, runData, attemptedErrors, }) => {
const kind = errorKind ??
(error instanceof errors_1.MaxTurnsExceededError
? 'maxTurns'
: error instanceof errors_1.ModelRefusalError
? 'modelRefusal'
: undefined);
if (!kind) {
return undefined;
}
const typedError = kind === 'maxTurns' && error instanceof errors_1.MaxTurnsExceededError
? error
: kind === 'modelRefusal' && error instanceof errors_1.ModelRefusalError
? error
: kind === 'invalidFinalOutput' && error instanceof errors_1.ModelBehaviorError
? error
: undefined;
if (!typedError) {
return undefined;
}
const handler = errorHandlers?.[kind] ?? errorHandlers?.default;
if (!handler) {
return undefined;
}
if (attemptedErrors?.has(typedError)) {
return undefined;
}
attemptedErrors?.add(typedError);
invalidateAcceptedResponseReplayEvidence(runData.state);
const handlerResult = await handler({
error: typedError,
context,
runData,
});
return handlerResult || undefined;
};
exports.resolveRunErrorHandler = resolveRunErrorHandler;
const prepareRunErrorFinalOutput = async ({ error, state, errorHandlers, streamResult, responseAccepted, attemptedErrors, }) => {
const handlerResult = await (0, exports.resolveRunErrorHandler)({
error,
errorHandlers,
context: state._context,
runData: buildRunData(state),
attemptedErrors,
});
if (!handlerResult) {
return undefined;
}
const includeInHistory = handlerResult.includeInHistory !== false;
const outputText = formatFinalOutput(state._currentAgent, handlerResult.finalOutput);
validateRunErrorFinalOutput(state._currentAgent, outputText);
streamResult?._hideFinalOutput();
state._lastTurnResponse = undefined;
state._lastProcessedResponse = undefined;
const item = createFinalOutputItem(state._currentAgent, outputText);
const deferredItem = error instanceof errors_1.MaxTurnsExceededError && includeInHistory
? item
: undefined;
if (includeInHistory && !deferredItem) {
state._generatedItems.push(item);
}
if (streamResult &&
!deferredItem &&
(includeInHistory || !(error instanceof errors_1.MaxTurnsExceededError))) {
(0, streaming_1.streamStepItemsToRunResult)(streamResult, [item]);
}
state._currentStep = {
type: 'next_step_final_output',
output: outputText,
...(responseAccepted ? { responseAccepted: true } : {}),
};
state._finalOutputSource = 'error_handler';
return { deferredItem };
};
exports.prepareRunErrorFinalOutput = prepareRunErrorFinalOutput;
//# sourceMappingURL=errorHandlers.js.map