@openai/agents-core/dist/sandbox/shared/environment.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.materializeEnvironment = materializeEnvironment;
exports.materializeStaticEnvironment = materializeStaticEnvironment;
exports.mergeMaterializedEnvironment = mergeMaterializedEnvironment;
exports.mergeStaticMaterializedEnvironment = mergeStaticMaterializedEnvironment;
exports.serializeManifestEnvironment = serializeManifestEnvironment;
exports.serializeRuntimeEnvironmentForPersistence = serializeRuntimeEnvironmentForPersistence;
exports.deserializePersistedEnvironmentForRuntime = deserializePersistedEnvironmentForRuntime;
exports.rehydratePersistedEnvironmentForRuntime = rehydratePersistedEnvironmentForRuntime;
exports.resolveEnvironmentReferences = resolveEnvironmentReferences;
exports.assertShellEnvironmentName = assertShellEnvironmentName;
const errors_1 = require("../../errors.js");
const manifest_1 = require("../manifest.js");
const SHELL_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
async function materializeEnvironment(manifest, baseEnvironment = {}) {
    return {
        ...baseEnvironment,
        ...(await manifest.resolveEnvironment()),
    };
}
function materializeStaticEnvironment(manifest) {
    return Object.fromEntries(Object.entries(manifest.environment).map(([key, value]) => [
        key,
        value.value,
    ]));
}
async function mergeMaterializedEnvironment(previousManifest, nextManifest, currentEnvironment) {
    const previousEnvironment = await materializeEnvironment(previousManifest);
    const runtimeEnvironmentDelta = Object.fromEntries(Object.entries(currentEnvironment).filter(([key, value]) => previousEnvironment[key] !== value));
    return await materializeEnvironment(nextManifest, runtimeEnvironmentDelta);
}
function mergeStaticMaterializedEnvironment(previousManifest, nextManifest, currentEnvironment) {
    const previousEnvironment = materializeStaticEnvironment(previousManifest);
    const runtimeEnvironmentDelta = Object.fromEntries(Object.entries(currentEnvironment).filter(([key, value]) => previousEnvironment[key] !== value));
    return {
        ...runtimeEnvironmentDelta,
        ...materializeStaticEnvironment(nextManifest),
    };
}
function serializeManifestEnvironment(manifest) {
    return Object.fromEntries(Object.entries(manifest.environment).map(([key, value]) => {
        if ((0, manifest_1.isEnvValueReference)(value)) {
            return [key, (0, manifest_1.serializeEnvValueReference)(value)];
        }
        return [key, value.normalized()];
    }));
}
function serializeRuntimeEnvironmentForPersistence(manifest, environment) {
    return Object.fromEntries(Object.entries(manifest.environment)
        .filter(([key, value]) => !value.ephemeral &&
        !(0, manifest_1.isEnvValueReference)(value) &&
        key in environment &&
        typeof environment[key] === 'string')
        .map(([key, value]) => [
        key,
        value.resolver ? environment[key] : value.value,
    ]));
}
function deserializePersistedEnvironmentForRuntime(manifest, environment, baseEnvironment = {}) {
    const manifestEnvironment = materializeStaticEnvironment(manifest);
    const persistentManifestEnvironment = Object.fromEntries(Object.entries(manifestEnvironment).filter(([key]) => !manifest.environment[key]?.ephemeral &&
        !(0, manifest_1.isEnvValueReference)(manifest.environment[key])));
    const persistedEnvironment = Object.fromEntries(Object.entries(environment ?? {}).filter(([key]) => key in manifestEnvironment &&
        !manifest.environment[key]?.ephemeral &&
        !(0, manifest_1.isEnvValueReference)(manifest.environment[key])));
    return {
        ...baseEnvironment,
        ...persistentManifestEnvironment,
        ...persistedEnvironment,
    };
}
async function rehydratePersistedEnvironmentForRuntime(manifest, environment, baseEnvironment = {}) {
    const runtimeEnvironment = deserializePersistedEnvironmentForRuntime(manifest, environment, baseEnvironment);
    const resolvedReferences = await resolveEnvironmentReferences(manifest);
    return {
        ...runtimeEnvironment,
        ...resolvedReferences,
    };
}
async function resolveEnvironmentReferences(manifest) {
    return Object.fromEntries(await Promise.all(Object.entries(manifest.environment)
        .filter(([, value]) => (0, manifest_1.isEnvValueReference)(value))
        .map(async ([key, value]) => [key, await value.resolve()])));
}
function assertShellEnvironmentName(name) {
    if (!SHELL_ENV_NAME_PATTERN.test(name)) {
        throw new errors_1.UserError(`Invalid environment variable name "${name}". Environment names used in shell commands must match ${SHELL_ENV_NAME_PATTERN.source}.`);
    }
}
//# sourceMappingURL=environment.js.map