@openai/agents-core/dist/sandbox/client.mjs

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

import { cloneManifest, Manifest } from "./manifest.mjs";
import { validateMountCredentialBoundaries, validateMountEnvironmentCredentialBoundaries, } from "./mountSecurity.mjs";
import { isRecord } from "./shared/typeGuards.mjs";
import { UserError } from "../errors.mjs";
export const DEFAULT_SANDBOX_ARCHIVE_LIMITS = {
    maxInputBytes: 1024 * 1024 * 1024,
    maxExtractedBytes: 4 * 1024 * 1024 * 1024,
    maxMembers: 100_000,
};
export function normalizeSandboxClientCreateArgs(args, manifestOptions, validationOptions = {}) {
    if (args instanceof Manifest) {
        const manifest = cloneManifest(args);
        validateMountCredentialBoundaries(manifest);
        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
        ? cloneManifest(manifest)
        : new Manifest();
    validateMountCredentialBoundaries(normalizedManifest);
    validateMountEnvironmentCredentialBoundaries(normalizedManifest, {}, {
        preserveDeferredValuePresence: validationOptions.environmentPreparation === 'client',
    });
    return {
        manifest: normalizedManifest,
        options: args?.options,
        snapshot: args?.snapshot,
        concurrencyLimits: args?.concurrencyLimits,
        archiveLimits: args?.archiveLimits,
    };
}
export function resolveSandboxArchiveLimits(limits) {
    if (limits == null) {
        return null;
    }
    validateSandboxArchiveLimits(limits);
    return {
        maxInputBytes: limits.maxInputBytes === undefined
            ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxInputBytes
            : limits.maxInputBytes,
        maxExtractedBytes: limits.maxExtractedBytes === undefined
            ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxExtractedBytes
            : limits.maxExtractedBytes,
        maxMembers: limits.maxMembers === undefined
            ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxMembers
            : limits.maxMembers,
    };
}
export 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 UserError(`archiveLimits.${name} must be at least 1.`);
    }
}
function readSnapshotOption(options) {
    if (!isRecord(options)) {
        return undefined;
    }
    return options.snapshot;
}
function readConcurrencyLimitsOption(options) {
    if (!isRecord(options)) {
        return undefined;
    }
    return options.concurrencyLimits;
}
function readArchiveLimitsOption(options) {
    if (!isRecord(options)) {
        return undefined;
    }
    return options.archiveLimits;
}
//# sourceMappingURL=client.mjs.map