@openai/agents-core/dist/sandbox/client.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.DEFAULT_SANDBOX_ARCHIVE_LIMITS = void 0;
exports.normalizeSandboxClientCreateArgs = normalizeSandboxClientCreateArgs;
exports.resolveSandboxArchiveLimits = resolveSandboxArchiveLimits;
exports.validateSandboxArchiveLimits = validateSandboxArchiveLimits;
const manifest_1 = require("./manifest.js");
const mountSecurity_1 = require("./mountSecurity.js");
const typeGuards_1 = require("./shared/typeGuards.js");
const errors_1 = require("../errors.js");
exports.DEFAULT_SANDBOX_ARCHIVE_LIMITS = {
    maxInputBytes: 1024 * 1024 * 1024,
    maxExtractedBytes: 4 * 1024 * 1024 * 1024,
    maxMembers: 100_000,
};
function normalizeSandboxClientCreateArgs(args, manifestOptions, validationOptions = {}) {
    if (args instanceof manifest_1.Manifest) {
        const manifest = (0, manifest_1.cloneManifest)(args);
        (0, mountSecurity_1.validateMountCredentialBoundaries)(manifest);
        (0, mountSecurity_1.validateMountEnvironmentCredentialBoundaries)(manifest, {}, {
            preserveDeferredValuePresence: validationOptions.environmentPreparation === 'client',
        });
        return {
            manifest,
            options: manifestOptions,
            snapshot: readSnapshotOption(manifestOptions),
            concurrencyLimits: readConcurrencyLimitsOption(manifestOptions),
            archiveLimits: readArchiveLimitsOption(manifestOptions),
        };
    }
    const manifest = args?.manifest;
    const normalizedManifest = manifest
        ? (0, manifest_1.cloneManifest)(manifest)
        : new manifest_1.Manifest();
    (0, mountSecurity_1.validateMountCredentialBoundaries)(normalizedManifest);
    (0, mountSecurity_1.validateMountEnvironmentCredentialBoundaries)(normalizedManifest, {}, {
        preserveDeferredValuePresence: validationOptions.environmentPreparation === 'client',
    });
    return {
        manifest: normalizedManifest,
        options: args?.options,
        snapshot: args?.snapshot,
        concurrencyLimits: args?.concurrencyLimits,
        archiveLimits: args?.archiveLimits,
    };
}
function resolveSandboxArchiveLimits(limits) {
    if (limits == null) {
        return null;
    }
    validateSandboxArchiveLimits(limits);
    return {
        maxInputBytes: limits.maxInputBytes === undefined
            ? exports.DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxInputBytes
            : limits.maxInputBytes,
        maxExtractedBytes: limits.maxExtractedBytes === undefined
            ? exports.DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxExtractedBytes
            : limits.maxExtractedBytes,
        maxMembers: limits.maxMembers === undefined
            ? exports.DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxMembers
            : limits.maxMembers,
    };
}
function validateSandboxArchiveLimits(limits) {
    if (limits == null) {
        return;
    }
    validatePositiveArchiveLimit('maxInputBytes', limits.maxInputBytes);
    validatePositiveArchiveLimit('maxExtractedBytes', limits.maxExtractedBytes);
    validatePositiveArchiveLimit('maxMembers', limits.maxMembers);
}
function validatePositiveArchiveLimit(name, value) {
    if (value == null) {
        return;
    }
    if (!Number.isSafeInteger(value) || value < 1) {
        throw new errors_1.UserError(`archiveLimits.${name} must be at least 1.`);
    }
}
function readSnapshotOption(options) {
    if (!(0, typeGuards_1.isRecord)(options)) {
        return undefined;
    }
    return options.snapshot;
}
function readConcurrencyLimitsOption(options) {
    if (!(0, typeGuards_1.isRecord)(options)) {
        return undefined;
    }
    return options.concurrencyLimits;
}
function readArchiveLimitsOption(options) {
    if (!(0, typeGuards_1.isRecord)(options)) {
        return undefined;
    }
    return options.archiveLimits;
}
//# sourceMappingURL=client.js.map