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

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

import { Usage, cloneTokenDetails } from "../usage.mjs";
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({
        requests: usage.requests,
        inputTokens: usage.inputTokens,
        outputTokens: usage.outputTokens,
        totalTokens: usage.totalTokens,
        inputTokensDetails: usage.inputTokensDetails.map(cloneTokenDetails),
        outputTokensDetails: usage.outputTokensDetails.map(cloneTokenDetails),
        requestUsageEntries: usage.requestUsageEntries?.map((entry) => ({
            inputTokens: entry.inputTokens,
            outputTokens: entry.outputTokens,
            totalTokens: entry.totalTokens,
            inputTokensDetails: cloneTokenDetails(entry.inputTokensDetails),
            outputTokensDetails: cloneTokenDetails(entry.outputTokensDetails),
            endpoint: entry.endpoint,
        })),
    });
}
export function setRunnerParentUsageRecorder(runner, recorder) {
    if (recorder) {
        runnerParentUsageRecorders.set(runner, recorder);
    }
    else {
        runnerParentUsageRecorders.delete(runner);
    }
}
export function getRunnerParentUsageRecorder(runner) {
    return runnerParentUsageRecorders.get(runner);
}
export function setRunStateUsageRecorder(state, recorder) {
    runStateUsageRecorders.set(state, recorder);
}
export function getRunStateUsageRecorder(state) {
    return runStateUsageRecorders.get(state);
}
export function setToolUsageRecorder(details, recorder) {
    if (!recorder) {
        return;
    }
    Object.defineProperty(details, TOOL_USAGE_RECORDER_SYMBOL, {
        value: recorder,
        enumerable: false,
        configurable: true,
        writable: false,
    });
}
export function getToolUsageRecorder(details) {
    if (!details || typeof details !== 'object') {
        return undefined;
    }
    return details[TOOL_USAGE_RECORDER_SYMBOL];
}
export function recordToolUsage(details, usage) {
    getToolUsageRecorder(details)?.(usage);
}
export function createModelFailureUsageScope(request, recorder) {
    const internal = { ...request._internal };
    modelFailureUsageRecorders.set(internal, recorder);
    return {
        request: { ...request, _internal: internal },
        close: () => modelFailureUsageRecorders.delete(internal),
    };
}
export function reportModelFailureUsage(request, error, usage) {
    const internal = request._internal;
    const recorder = internal && modelFailureUsageRecorders.get(internal);
    if (recorder) {
        recorder(cloneUsage(usage));
    }
    else {
        attachModelFailureUsage(error, usage);
    }
}
export 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);
}
export 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.mjs.map