@openai/agents-core/dist/agentToolRunConfig.mjs

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

import { mergeModelSettings } from "./runner/modelSettingsMerge.mjs";
import { mergeTracingConfig } from "./tracing/config.mjs";
const TRANSPORT_OVERRIDE_PROVIDER_DATA_ALIAS_KEYS = [
    ['extra_headers', 'extraHeaders'],
    ['extra_query', 'extraQuery'],
    ['extra_body', 'extraBody'],
];
// Runner and tool adapters can load separate CJS/ESM copies of core.
const AGENT_TOOL_PARENT_RUN_CONFIG_SYMBOL = Symbol.for('openai.agents.agentToolParentRunConfig');
const TOOL_CALL_PARENT_SPAN_SYMBOL = Symbol('openai.agents.toolCallParentSpan');
function isPlainObjectLike(value) {
    return typeof value === 'object' && value !== null && !Array.isArray(value);
}
function hasOwn(value, key) {
    return Object.prototype.hasOwnProperty.call(value, key);
}
export function setAgentToolParentRunConfigOnDetails(details, parentRunConfig) {
    const safeParentRunConfig = {
        ...getInheritedAgentToolRunConfig(parentRunConfig, undefined),
        // The invoking tool needs this policy even though nested runners do not inherit it.
        ...(typeof parentRunConfig?.traceIncludeSensitiveData !== 'undefined'
            ? { traceIncludeSensitiveData: parentRunConfig.traceIncludeSensitiveData }
            : {}),
    };
    if (Object.keys(safeParentRunConfig).length === 0) {
        return;
    }
    Object.defineProperty(details, AGENT_TOOL_PARENT_RUN_CONFIG_SYMBOL, {
        value: safeParentRunConfig,
        enumerable: false,
        configurable: true,
        writable: false,
    });
}
export function getAgentToolParentRunConfigFromDetails(details) {
    if (!details || typeof details !== 'object') {
        return undefined;
    }
    const detailsRecord = details;
    const internalParentRunConfig = detailsRecord[AGENT_TOOL_PARENT_RUN_CONFIG_SYMBOL];
    if (typeof internalParentRunConfig !== 'undefined') {
        return internalParentRunConfig;
    }
    // Backward compatibility for direct/manual tool invocation tests and callers.
    const legacyParentRunConfig = detailsRecord.parentRunConfig;
    return isPlainObjectLike(legacyParentRunConfig)
        ? legacyParentRunConfig
        : undefined;
}
export function setToolCallParentSpanOnDetails(details, parent) {
    if (!parent) {
        return;
    }
    Object.defineProperty(details, TOOL_CALL_PARENT_SPAN_SYMBOL, {
        value: parent,
        enumerable: false,
        configurable: true,
        writable: false,
    });
}
export function getToolCallParentSpanFromDetails(details) {
    if (!details || typeof details !== 'object') {
        return undefined;
    }
    return details[TOOL_CALL_PARENT_SPAN_SYMBOL];
}
function getSafeInheritedAgentToolModelSettings(modelSettings, explicitModel) {
    if (!modelSettings) {
        return undefined;
    }
    // Tool-selection settings are specific to the outer agent/tool set and can
    // break nested Agent.asTool runs when inherited blindly.
    const { toolChoice: _toolChoice, parallelToolCalls: _parallelToolCalls, ...safeModelSettings } = modelSettings;
    // An explicit Model owns its client. Parent transport overrides must be
    // supplied explicitly again when crossing that boundary.
    if (typeof explicitModel === 'object' && safeModelSettings.providerData) {
        const providerData = { ...safeModelSettings.providerData };
        for (const aliases of TRANSPORT_OVERRIDE_PROVIDER_DATA_ALIAS_KEYS) {
            for (const key of aliases) {
                delete providerData[key];
            }
        }
        safeModelSettings.providerData = providerData;
    }
    return Object.keys(safeModelSettings).length > 0
        ? safeModelSettings
        : undefined;
}
function mergeNestedObjectMap(targetRecord, inheritedRecord, overrideRecord, key) {
    if (isPlainObjectLike(inheritedRecord[key]) &&
        isPlainObjectLike(overrideRecord[key])) {
        targetRecord[key] = {
            ...inheritedRecord[key],
            ...overrideRecord[key],
        };
    }
}
function getMergedProviderDataAliasMap(providerData, firstKey, secondKey) {
    const firstValue = providerData[firstKey];
    const secondValue = providerData[secondKey];
    const hasFirst = typeof firstValue !== 'undefined';
    const hasSecond = typeof secondValue !== 'undefined';
    if (!hasFirst && !hasSecond) {
        return undefined;
    }
    if ((hasFirst && !isPlainObjectLike(firstValue)) ||
        (hasSecond && !isPlainObjectLike(secondValue))) {
        return undefined;
    }
    return {
        ...(hasFirst ? firstValue : {}),
        ...(hasSecond ? secondValue : {}),
    };
}
function mergeTransportOverrideAliasMaps(targetProviderData, inheritedProviderData, toolProviderData, snakeKey, camelKey) {
    const inheritedMerged = getMergedProviderDataAliasMap(inheritedProviderData, snakeKey, camelKey);
    const toolMerged = getMergedProviderDataAliasMap(toolProviderData, snakeKey, camelKey);
    if (!inheritedMerged || !toolMerged) {
        return;
    }
    const mergedAliasMap = {
        ...inheritedMerged,
        ...toolMerged,
    };
    const aliasKeys = [snakeKey, camelKey];
    for (const aliasKey of aliasKeys) {
        if (hasOwn(inheritedProviderData, aliasKey) ||
            hasOwn(toolProviderData, aliasKey)) {
            targetProviderData[aliasKey] = mergedAliasMap;
        }
    }
}
function mergeAgentToolProviderData(inheritedProviderData, toolProviderData) {
    const mergedProviderData = {
        ...inheritedProviderData,
        ...toolProviderData,
    };
    for (const [snakeKey, camelKey,] of TRANSPORT_OVERRIDE_PROVIDER_DATA_ALIAS_KEYS) {
        mergeNestedObjectMap(mergedProviderData, inheritedProviderData, toolProviderData, snakeKey);
        mergeNestedObjectMap(mergedProviderData, inheritedProviderData, toolProviderData, camelKey);
    }
    for (const [snakeKey, camelKey,] of TRANSPORT_OVERRIDE_PROVIDER_DATA_ALIAS_KEYS) {
        mergeTransportOverrideAliasMaps(mergedProviderData, inheritedProviderData, toolProviderData, snakeKey, camelKey);
    }
    return mergedProviderData;
}
function mergeAgentToolModelSettings(inheritedRunConfig, toolRunConfigOverride) {
    const inheritedModelSettings = inheritedRunConfig.modelSettings;
    const toolModelSettings = toolRunConfigOverride.modelSettings;
    const hasToolModelSettingsOverride = hasOwn(toolRunConfigOverride, 'modelSettings');
    if (!inheritedModelSettings ||
        !hasToolModelSettingsOverride ||
        !toolModelSettings) {
        return undefined;
    }
    const mergedModelSettings = mergeModelSettings(inheritedModelSettings, toolModelSettings);
    const inheritedProviderData = inheritedModelSettings.providerData;
    const toolProviderData = toolModelSettings.providerData;
    const hasToolProviderDataOverride = hasOwn(toolModelSettings, 'providerData');
    if (hasToolProviderDataOverride &&
        isPlainObjectLike(inheritedProviderData) &&
        isPlainObjectLike(toolProviderData)) {
        mergedModelSettings.providerData = mergeAgentToolProviderData(inheritedProviderData, toolProviderData);
    }
    return mergedModelSettings;
}
export function getInheritedAgentToolRunConfig(parentRunConfig, toolRunConfigOverride, explicitModel) {
    if (!parentRunConfig) {
        return undefined;
    }
    const inheritedRunConfig = {};
    const overridesModelProvider = typeof toolRunConfigOverride?.modelProvider !== 'undefined';
    if (typeof parentRunConfig.modelProvider !== 'undefined') {
        inheritedRunConfig.modelProvider = parentRunConfig.modelProvider;
    }
    if (!overridesModelProvider && typeof parentRunConfig.model !== 'undefined') {
        inheritedRunConfig.model = parentRunConfig.model;
    }
    if (!overridesModelProvider &&
        typeof parentRunConfig.modelSettings !== 'undefined') {
        const inheritedModelSettings = getSafeInheritedAgentToolModelSettings(parentRunConfig.modelSettings, explicitModel);
        if (typeof inheritedModelSettings !== 'undefined') {
            inheritedRunConfig.modelSettings = inheritedModelSettings;
        }
    }
    if (typeof parentRunConfig.sandbox !== 'undefined') {
        inheritedRunConfig.sandbox = parentRunConfig.sandbox;
    }
    if (typeof parentRunConfig.toolExecution !== 'undefined') {
        inheritedRunConfig.toolExecution = parentRunConfig.toolExecution;
    }
    if (typeof parentRunConfig.toolNotFoundBehavior !== 'undefined') {
        inheritedRunConfig.toolNotFoundBehavior =
            parentRunConfig.toolNotFoundBehavior;
    }
    if (typeof parentRunConfig.toolNameCollisionPolicy !== 'undefined') {
        inheritedRunConfig.toolNameCollisionPolicy =
            parentRunConfig.toolNameCollisionPolicy;
    }
    if (typeof parentRunConfig.tracing !== 'undefined') {
        inheritedRunConfig.tracing = parentRunConfig.tracing;
    }
    if (typeof parentRunConfig.tracingDisabled !== 'undefined' &&
        typeof toolRunConfigOverride?.tracingDisabled === 'undefined') {
        inheritedRunConfig.tracingDisabled = parentRunConfig.tracingDisabled;
    }
    return Object.keys(inheritedRunConfig).length > 0
        ? inheritedRunConfig
        : undefined;
}
export function mergeAgentToolRunConfig(inheritedRunConfig, toolRunConfigOverride) {
    if (!inheritedRunConfig) {
        return toolRunConfigOverride ?? {};
    }
    if (!toolRunConfigOverride) {
        return inheritedRunConfig;
    }
    const mergedRunConfig = {
        ...inheritedRunConfig,
        ...toolRunConfigOverride,
    };
    const mergedModelSettings = mergeAgentToolModelSettings(inheritedRunConfig, toolRunConfigOverride);
    if (typeof mergedModelSettings !== 'undefined') {
        mergedRunConfig.modelSettings = mergedModelSettings;
    }
    const mergedTracing = mergeTracingConfig(inheritedRunConfig.tracing, toolRunConfigOverride.tracing);
    if (typeof mergedTracing !== 'undefined') {
        mergedRunConfig.tracing = mergedTracing;
    }
    return mergedRunConfig;
}
//# sourceMappingURL=agentToolRunConfig.mjs.map