@sap-ai-sdk/orchestration/dist/util/module-config.js

SAP Cloud SDK for AI is the official Software Development Kit (SDK) for **SAP AI Core**, **SAP Generative AI Hub**, and **Orchestration Service**.

import { createLogger } from '@sap-cloud-sdk/util';
const logger = createLogger({
    package: 'orchestration',
    messageContext: 'orchestration-utils'
});
/**
 * @internal
 */
export function constructCompletionPostRequestFromJsonModuleConfig(config, prompt, stream) {
    const orchestration_config = { ...config };
    if (stream) {
        orchestration_config.stream = true;
    }
    else {
        delete orchestration_config.stream;
    }
    return {
        messages_history: prompt?.messagesHistory || [],
        input_params: prompt?.inputParams || {},
        orchestration_config
    };
}
/**
 * @internal
 */
export function addStreamOptionsToLlmModuleConfig(llmModuleConfig, streamOptions) {
    if (streamOptions?.llm === null) {
        return llmModuleConfig;
    }
    return {
        ...llmModuleConfig,
        model_params: {
            ...llmModuleConfig.model_params,
            ...(streamOptions?.llm !== null && {
                stream_options: {
                    include_usage: true,
                    ...(llmModuleConfig.model_params?.stream_options || {}),
                    ...(streamOptions?.llm || {})
                }
            })
        }
    };
}
/**
 * @internal
 */
export function addStreamOptionsToOutputFilteringConfig(outputFilteringConfig, filteringStreamOptions) {
    return {
        ...outputFilteringConfig,
        stream_options: {
            ...(outputFilteringConfig.stream_options || {}),
            ...filteringStreamOptions
        }
    };
}
/**
 * @internal
 */
export function addStreamOptions(moduleConfigs, streamOptions) {
    const { llm_module_config, filtering_module_config } = moduleConfigs;
    const outputFiltering = streamOptions?.outputFiltering;
    const globalOptions = streamOptions?.global;
    if (!moduleConfigs?.filtering_module_config?.output && outputFiltering) {
        logger.warn('Output filter stream options are not applied because filtering module is not configured.');
    }
    return {
        stream: true,
        ...(globalOptions && { stream_options: globalOptions }),
        module_configurations: {
            ...moduleConfigs,
            llm_module_config: addStreamOptionsToLlmModuleConfig(llm_module_config, streamOptions),
            ...(outputFiltering &&
                filtering_module_config?.output && {
                filtering_module_config: {
                    ...filtering_module_config,
                    output: addStreamOptionsToOutputFilteringConfig(filtering_module_config.output, outputFiltering)
                }
            })
        }
    };
}
/**
 * @internal
 */
export function constructCompletionPostRequest(config, prompt, stream, streamOptions) {
    // Templating is not a string here as it is already parsed in `parseAndMergeTemplating` method
    const templatingConfig = { ...config.templating };
    if (isTemplate(templatingConfig)) {
        if (!templatingConfig.template?.length && !prompt?.messages?.length) {
            throw new Error('Either a prompt template or messages must be defined.');
        }
        if (prompt?.messages?.length) {
            templatingConfig.template = [
                ...(templatingConfig.template || []),
                ...prompt.messages
            ];
        }
    }
    const moduleConfigurations = {
        templating_module_config: templatingConfig,
        llm_module_config: config.llm,
        ...(config?.filtering &&
            Object.keys(config.filtering).length && {
            filtering_module_config: config.filtering
        }),
        ...(config?.masking &&
            Object.keys(config.masking).length && {
            masking_module_config: config.masking
        }),
        ...(config?.grounding &&
            Object.keys(config.grounding).length && {
            grounding_module_config: config.grounding
        }),
        ...(config?.inputTranslation &&
            Object.keys(config.inputTranslation).length && {
            input_translation_module_config: config.inputTranslation
        }),
        ...(config?.outputTranslation &&
            Object.keys(config.outputTranslation).length && {
            output_translation_module_config: config.outputTranslation
        })
    };
    return {
        orchestration_config: stream
            ? addStreamOptions(moduleConfigurations, mergeStreamOptions(config.streaming, streamOptions))
            : { module_configurations: moduleConfigurations },
        ...(prompt?.inputParams && {
            input_params: prompt.inputParams
        }),
        ...(prompt?.messagesHistory && {
            messages_history: prompt.messagesHistory
        })
    };
}
function mergeStreamOptions(globalOptions, streamOptions) {
    return {
        ...streamOptions,
        ...((globalOptions || streamOptions?.global) && {
            global: {
                ...globalOptions,
                ...streamOptions?.global
            }
        })
    };
}
function isTemplate(templating) {
    return (templating &&
        typeof templating === 'object' &&
        !('template_ref' in templating));
}
//# sourceMappingURL=module-config.js.map