@openai/agents-core/dist/runner/usageTracking.js

The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.setRunnerParentUsageRecorder = setRunnerParentUsageRecorder;
exports.getRunnerParentUsageRecorder = getRunnerParentUsageRecorder;
exports.setRunStateUsageRecorder = setRunStateUsageRecorder;
exports.getRunStateUsageRecorder = getRunStateUsageRecorder;
exports.setToolUsageRecorder = setToolUsageRecorder;
exports.getToolUsageRecorder = getToolUsageRecorder;
exports.recordToolUsage = recordToolUsage;
exports.createModelFailureUsageScope = createModelFailureUsageScope;
exports.reportModelFailureUsage = reportModelFailureUsage;
exports.attachModelFailureUsage = attachModelFailureUsage;
exports.consumeModelFailureUsage = consumeModelFailureUsage;
const usage_1 = require("../usage.js");
const TOOL_USAGE_RECORDER_SYMBOL = Symbol.for('openai.agents.core.toolUsageRecorder');
const runnerParentUsageRecorders = new WeakMap();
const runStateUsageRecorders = new WeakMap();
const modelFailureUsageRecorders = new WeakMap();
const modelFailureUsageByError = new WeakMap();
function cloneUsage(usage) {
    return new usage_1.Usage({
        requests: usage.requests,
        inputTokens: usage.inputTokens,
        outputTokens: usage.outputTokens,
        totalTokens: usage.totalTokens,
        inputTokensDetails: usage.inputTokensDetails.map(usage_1.cloneTokenDetails),
        outputTokensDetails: usage.outputTokensDetails.map(usage_1.cloneTokenDetails),
        requestUsageEntries: usage.requestUsageEntries?.map((entry) => ({
            inputTokens: entry.inputTokens,
            outputTokens: entry.outputTokens,
            totalTokens: entry.totalTokens,
            inputTokensDetails: (0, usage_1.cloneTokenDetails)(entry.inputTokensDetails),
            outputTokensDetails: (0, usage_1.cloneTokenDetails)(entry.outputTokensDetails),
            endpoint: entry.endpoint,
        })),
    });
}
function setRunnerParentUsageRecorder(runner, recorder) {
    if (recorder) {
        runnerParentUsageRecorders.set(runner, recorder);
    }
    else {
        runnerParentUsageRecorders.delete(runner);
    }
}
function getRunnerParentUsageRecorder(runner) {
    return runnerParentUsageRecorders.get(runner);
}
function setRunStateUsageRecorder(state, recorder) {
    runStateUsageRecorders.set(state, recorder);
}
function getRunStateUsageRecorder(state) {
    return runStateUsageRecorders.get(state);
}
function setToolUsageRecorder(details, recorder) {
    if (!recorder) {
        return;
    }
    Object.defineProperty(details, TOOL_USAGE_RECORDER_SYMBOL, {
        value: recorder,
        enumerable: false,
        configurable: true,
        writable: false,
    });
}
function getToolUsageRecorder(details) {
    if (!details || typeof details !== 'object') {
        return undefined;
    }
    return details[TOOL_USAGE_RECORDER_SYMBOL];
}
function recordToolUsage(details, usage) {
    getToolUsageRecorder(details)?.(usage);
}
function createModelFailureUsageScope(request, recorder) {
    const internal = { ...request._internal };
    modelFailureUsageRecorders.set(internal, recorder);
    return {
        request: { ...request, _internal: internal },
        close: () => modelFailureUsageRecorders.delete(internal),
    };
}
function reportModelFailureUsage(request, error, usage) {
    const internal = request._internal;
    const recorder = internal && modelFailureUsageRecorders.get(internal);
    if (recorder) {
        recorder(cloneUsage(usage));
    }
    else {
        attachModelFailureUsage(error, usage);
    }
}
function attachModelFailureUsage(error, usage) {
    if (!error || typeof error !== 'object') {
        return;
    }
    const existing = modelFailureUsageByError.get(error);
    const combinedUsage = cloneUsage(usage);
    if (existing) {
        combinedUsage.add(existing);
    }
    modelFailureUsageByError.set(error, combinedUsage);
}
function consumeModelFailureUsage(error) {
    if (!error || typeof error !== 'object') {
        return undefined;
    }
    const usage = modelFailureUsageByError.get(error);
    if (!usage) {
        return undefined;
    }
    modelFailureUsageByError.delete(error);
    return cloneUsage(usage);
}
//# sourceMappingURL=usageTracking.js.map