@openai/agents-core/dist/usage.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.UsageData = exports.RequestUsageData = exports.Usage = exports.RequestUsage = void 0;
exports.cloneTokenDetails = cloneTokenDetails;
const protocol_1 = require("./types/protocol.js");
Object.defineProperty(exports, "RequestUsageData", { enumerable: true, get: function () { return protocol_1.RequestUsageData; } });
Object.defineProperty(exports, "UsageData", { enumerable: true, get: function () { return protocol_1.UsageData; } });
/**
 * Usage details for a single API request.
 */
class RequestUsage {
    /**
     * The number of input tokens used for this request.
     */
    inputTokens;
    /**
     * The number of output tokens used for this request.
     */
    outputTokens;
    /**
     * The total number of tokens sent and received for this request.
     */
    totalTokens;
    /**
     * Details about the input tokens used for this request.
     */
    inputTokensDetails;
    /**
     * Details about the output tokens used for this request.
     */
    outputTokensDetails;
    /**
     * The endpoint that produced this usage entry (e.g., responses.create, responses.compact).
     */
    endpoint;
    constructor(input) {
        this.inputTokens = input?.inputTokens ?? input?.input_tokens ?? 0;
        this.outputTokens = input?.outputTokens ?? input?.output_tokens ?? 0;
        this.totalTokens =
            input?.totalTokens ??
                input?.total_tokens ??
                this.inputTokens + this.outputTokens;
        const inputTokensDetails = input?.inputTokensDetails ?? input?.input_tokens_details;
        this.inputTokensDetails = inputTokensDetails
            ? cloneTokenDetails(inputTokensDetails)
            : {};
        const outputTokensDetails = input?.outputTokensDetails ?? input?.output_tokens_details;
        this.outputTokensDetails = outputTokensDetails
            ? cloneTokenDetails(outputTokensDetails)
            : {};
        if (typeof input?.endpoint !== 'undefined') {
            this.endpoint = input.endpoint;
        }
    }
    /**
     * Reconstructs a RequestUsage instance from a JSON-compatible wire value.
     */
    static fromJSON(input) {
        return new RequestUsage(input);
    }
}
exports.RequestUsage = RequestUsage;
function cloneTokenDetails(details) {
    return protocol_1.TokenDetails.parse(details);
}
function cloneRequestUsage(input) {
    return new RequestUsage(input);
}
/**
 * Tracks token usage and request counts for an agent run.
 */
class Usage {
    /**
     * The number of requests made to the LLM API.
     */
    requests;
    /**
     * The number of input tokens used across all requests.
     */
    inputTokens;
    /**
     * The number of output tokens used across all requests.
     */
    outputTokens;
    /**
     * The total number of tokens sent and received, across all requests.
     */
    totalTokens;
    /**
     * Details about the input tokens used across all requests.
     */
    inputTokensDetails = [];
    /**
     * Details about the output tokens used across all requests.
     */
    outputTokensDetails = [];
    /**
     * List of per-request usage entries for detailed cost calculations.
     */
    requestUsageEntries;
    constructor(input) {
        if (typeof input === 'undefined') {
            this.requests = 0;
            this.inputTokens = 0;
            this.outputTokens = 0;
            this.totalTokens = 0;
            this.inputTokensDetails = [];
            this.outputTokensDetails = [];
            this.requestUsageEntries = undefined;
        }
        else {
            this.requests = input?.requests ?? 1;
            this.inputTokens = input?.inputTokens ?? input?.input_tokens ?? 0;
            this.outputTokens = input?.outputTokens ?? input?.output_tokens ?? 0;
            this.totalTokens =
                input?.totalTokens ??
                    input?.total_tokens ??
                    this.inputTokens + this.outputTokens;
            const inputTokensDetails = input?.inputTokensDetails ?? input?.input_tokens_details;
            if (Array.isArray(inputTokensDetails)) {
                this.inputTokensDetails = inputTokensDetails.map(cloneTokenDetails);
            }
            else {
                this.inputTokensDetails = inputTokensDetails
                    ? [cloneTokenDetails(inputTokensDetails)]
                    : [];
            }
            const outputTokensDetails = input?.outputTokensDetails ?? input?.output_tokens_details;
            if (Array.isArray(outputTokensDetails)) {
                this.outputTokensDetails = outputTokensDetails.map(cloneTokenDetails);
            }
            else {
                this.outputTokensDetails = outputTokensDetails
                    ? [cloneTokenDetails(outputTokensDetails)]
                    : [];
            }
            const requestUsageEntries = input?.requestUsageEntries ?? input?.request_usage_entries;
            const normalizedRequestUsageEntries = Array.isArray(requestUsageEntries)
                ? requestUsageEntries.map(cloneRequestUsage)
                : undefined;
            this.requestUsageEntries =
                normalizedRequestUsageEntries &&
                    normalizedRequestUsageEntries.length > 0
                    ? normalizedRequestUsageEntries
                    : undefined;
        }
    }
    /**
     * Reconstructs a Usage instance from a JSON-compatible wire value.
     */
    static fromJSON(input) {
        return new Usage(input);
    }
    add(newUsage) {
        // Validate and copy all incoming details before changing aggregate usage.
        const inputDetails = newUsage.inputTokensDetails?.map(cloneTokenDetails) ?? [];
        const outputDetails = newUsage.outputTokensDetails?.map(cloneTokenDetails) ?? [];
        let requestEntries = [];
        if (Array.isArray(newUsage.requestUsageEntries) &&
            newUsage.requestUsageEntries.length > 0) {
            requestEntries = newUsage.requestUsageEntries.map(cloneRequestUsage);
        }
        else if (newUsage.requests === 1 && newUsage.totalTokens > 0) {
            requestEntries = [
                cloneRequestUsage({
                    inputTokens: newUsage.inputTokens,
                    outputTokens: newUsage.outputTokens,
                    totalTokens: newUsage.totalTokens,
                    inputTokensDetails: newUsage.inputTokensDetails?.[0],
                    outputTokensDetails: newUsage.outputTokensDetails?.[0],
                }),
            ];
        }
        this.requests += newUsage.requests ?? 0;
        this.inputTokens += newUsage.inputTokens ?? 0;
        this.outputTokens += newUsage.outputTokens ?? 0;
        this.totalTokens += newUsage.totalTokens ?? 0;
        this.inputTokensDetails.push(...inputDetails);
        this.outputTokensDetails.push(...outputDetails);
        if (requestEntries.length > 0) {
            this.requestUsageEntries ??= [];
            this.requestUsageEntries.push(...requestEntries);
        }
    }
}
exports.Usage = Usage;
//# sourceMappingURL=usage.js.map