@truefoundry/ai-gateway-sdk 0.0.0-stage → 0.0.1

package/dist/providers/bedrock/utils.js

@@ -0,0 +1,652 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. getCredentialsFromAssumedRole has been modified to support two-step role assumption:
+ *    - First assumes the gateway cross-account role using gateway user credentials
+ *    - Then assumes the customer's role using the gateway cross-account role credentials
+ * 2. Fix unused vars for linting
+ * ================================
+ */
+import { AssumeRoleCommand, STSClient } from '@aws-sdk/client-sts';
+import { getCachedCredentials, storeCachedCredentials } from '../../cache/port.js';
+import config from '../../config.js';
+import { AuthenticationError, CredentialResolutionError, ValidationError } from '../../errors.js';
+import { AWS_BEDROCK_MANTLE, AWS_CLAUDE_PLATFORM, BEDROCK } from '../../globals.js';
+import { safeFetch } from '../../http/index.js';
+import { logger } from '../../logger.js';
+import { getAllowAmbientCredentials } from '../../runtime/ambientCredentials.js';
+import { createHashedCacheKey, credentialCacheExpiration, sanitizeNatsKey } from '../../utils.js';
+import { generateAWSHeaders } from '../../utils/awsSigV4.js';
+import { BEDROCK_CONVERSE_BETA_KEY, resolveAnthropicBetas } from '../anthropic/anthropicBetas.js';
+import { resolveServerTools } from '../anthropic/serverTools.js';
+import { anthropicBetaResolveFromParamMap, hashUserId, mergeAnthropicBetasWithOverride } from '../anthropic/utils.js';
+export { generateAWSHeaders };
+export const transformInferenceConfig = (params) => {
+    const inferenceConfig = {};
+    if (params['max_completion_tokens'] || params['max_tokens']) {
+        inferenceConfig['maxTokens'] = params['max_completion_tokens'] || params['max_tokens'];
+    }
+    if (params['stop']) {
+        inferenceConfig['stopSequences'] = params['stop'];
+    }
+    if (params['temperature']) {
+        inferenceConfig['temperature'] = params['temperature'];
+    }
+    if (params['top_p']) {
+        inferenceConfig['topP'] = params['top_p'];
+    }
+    return inferenceConfig;
+};
+export const transformParamsObjectForTaskType = (params) => {
+    const taskType = params.taskType || 'INPAINTING';
+    switch (taskType) {
+        case 'INPAINTING': {
+            const inPaintingParams = {};
+            if (params['image']) {
+                if (Array.isArray(params.image)) {
+                    inPaintingParams.image = params.image[0];
+                }
+                else {
+                    inPaintingParams.image = params.image;
+                }
+            }
+            if (params['mask']) {
+                inPaintingParams.maskImage = params.mask;
+            }
+            if (params['prompt']) {
+                inPaintingParams.text = params['prompt'];
+            }
+            if (params['maskPrompt']) {
+                inPaintingParams.maskPrompt = params['maskPrompt'];
+            }
+            if (params['negativeText']) {
+                inPaintingParams.negativeText = params['negativeText'];
+            }
+            return inPaintingParams;
+        }
+        case 'OUTPAINTING': {
+            const outPaintingParams = {};
+            if (params['image']) {
+                if (Array.isArray(params.image)) {
+                    outPaintingParams.image = params.image[0];
+                }
+                else {
+                    outPaintingParams.image = params.image;
+                }
+            }
+            if (params['prompt']) {
+                outPaintingParams.text = params['prompt'];
+            }
+            if (params['mask']) {
+                outPaintingParams.maskImage = params['mask'];
+            }
+            if (params['negativeText']) {
+                outPaintingParams.negativeText = params['negativeText'];
+            }
+            if (params['outPaintingMode']) {
+                outPaintingParams.outPaintingMode = params['outPaintingMode'];
+            }
+            return outPaintingParams;
+        }
+        case 'BACKGROUND_REMOVAL': {
+            const backgroundRemovalParams = {};
+            if (params['image']) {
+                if (Array.isArray(params.image)) {
+                    backgroundRemovalParams.image = params.image[0];
+                }
+                else {
+                    backgroundRemovalParams.image = params.image;
+                }
+            }
+            return backgroundRemovalParams;
+        }
+        case 'VIRTUAL_TRY_ON': {
+            const virtualTryOnParams = {};
+            if (params['image']) {
+                virtualTryOnParams.sourceImage = params['image'];
+            }
+            if (params['referenceImage']) {
+                virtualTryOnParams.referenceImage = params['referenceImage'];
+            }
+            if (params['maskType']) {
+                virtualTryOnParams.maskType = params['maskType'];
+            }
+            if (params['mask'] && params['maskType'] === 'IMAGE') {
+                if (!virtualTryOnParams.imageBasedMask) {
+                    virtualTryOnParams.imageBasedMask = {};
+                }
+                virtualTryOnParams.imageBasedMask.maskImage = params['mask'];
+            }
+            if (params['maskType'] === 'GARMENT') {
+                if (!virtualTryOnParams.garmentBasedMask) {
+                    virtualTryOnParams.garmentBasedMask = {};
+                }
+                if (params['maskShape']) {
+                    virtualTryOnParams.garmentBasedMask.maskShape = params['maskShape'];
+                }
+                if (params['garmentClass']) {
+                    virtualTryOnParams.garmentBasedMask.garmentClass = params['garmentClass'];
+                }
+                if (params['longSleeveStyle'] || params['tuckingStyle'] || params['outerLayerStyle']) {
+                    if (!virtualTryOnParams.garmentBasedMask.garmentStyling) {
+                        virtualTryOnParams.garmentBasedMask.garmentStyling = {};
+                    }
+                    if (params['longSleeveStyle']) {
+                        virtualTryOnParams.garmentBasedMask.garmentStyling.longSleeveStyle = params['longSleeveStyle'];
+                    }
+                    if (params['tuckingStyle']) {
+                        virtualTryOnParams.garmentBasedMask.garmentStyling.tuckingStyle = params['tuckingStyle'];
+                    }
+                    if (params['outerLayerStyle']) {
+                        virtualTryOnParams.garmentBasedMask.garmentStyling.outerLayerStyle = params['outerLayerStyle'];
+                    }
+                }
+            }
+            if (params['maskType'] === 'PROMPT') {
+                if (!virtualTryOnParams.promptBasedMask) {
+                    virtualTryOnParams.promptBasedMask = {};
+                }
+                if (params['maskShape']) {
+                    virtualTryOnParams.promptBasedMask.maskShape = params['maskShape'];
+                }
+                if (params['maskPrompt']) {
+                    virtualTryOnParams.promptBasedMask.maskPrompt = params['maskPrompt'];
+                }
+            }
+            if (params['preserveBodyPose'] || params['preserveHands'] || params['preserveFace']) {
+                if (!virtualTryOnParams.maskExclusions) {
+                    virtualTryOnParams.maskExclusions = {};
+                }
+                if (params['preserveBodyPose']) {
+                    virtualTryOnParams.maskExclusions.preserveBodyPose = params['preserveBodyPose'];
+                }
+                if (params['preserveHands']) {
+                    virtualTryOnParams.maskExclusions.preserveHands = params['preserveHands'];
+                }
+                if (params['preserveFace']) {
+                    virtualTryOnParams.maskExclusions.preserveFace = params['preserveFace'];
+                }
+            }
+            if (params['mergeStyle']) {
+                virtualTryOnParams.mergeStyle = params['mergeStyle'];
+            }
+            if (params['returnMask'] !== undefined) {
+                virtualTryOnParams.returnMask = params['returnMask'];
+            }
+            return virtualTryOnParams;
+        }
+    }
+};
+export const transformImageGenerationConfig = (params) => {
+    const imageGenerationConfig = {};
+    if (params['n']) {
+        imageGenerationConfig['numberOfImages'] = parseInt(params['n']);
+    }
+    if (params['size']) {
+        imageGenerationConfig['width'] = parseInt(params['size'].split('x')[0]);
+        imageGenerationConfig['height'] = parseInt(params['size'].split('x')[1]);
+    }
+    if (params['cfgScale']) {
+        imageGenerationConfig['cfgScale'] = parseFloat(params['cfgScale']);
+    }
+    if (params['seed']) {
+        imageGenerationConfig['seed'] = parseInt(params['seed']);
+    }
+    if (params['quality']) {
+        if (params.quality === 'hd' || params.quality === 'premium') {
+            imageGenerationConfig.quality = 'premium';
+        }
+        else {
+            imageGenerationConfig.quality = 'standard';
+        }
+    }
+    return imageGenerationConfig;
+};
+export const transformImageVariationParams = (params) => {
+    const imageVariationParams = {};
+    if (params['image']) {
+        if (Array.isArray(params['image'])) {
+            // If already an array, use it directly
+            imageVariationParams['images'] = params['image'];
+        }
+        else {
+            // If single string, wrap in array (Bedrock expects array)
+            imageVariationParams['images'] = [params['image']];
+        }
+    }
+    if (params['text']) {
+        imageVariationParams['text'] = params['text'];
+    }
+    if (params['negativeText']) {
+        imageVariationParams['negativeText'] = params['negativeText'];
+    }
+    if (params['similarityStrength']) {
+        imageVariationParams['similarityStrength'] = parseFloat(params['similarityStrength']);
+    }
+    return imageVariationParams;
+};
+export const transformAdditionalModelRequestFields = (params) => {
+    const additionalModelRequestFields = params.additionalModelRequestFields || params.additional_model_request_fields || {};
+    if (params['top_k']) {
+        additionalModelRequestFields['top_k'] = params['top_k'];
+    }
+    if (params['response_format']) {
+        additionalModelRequestFields['response_format'] = params['response_format'];
+    }
+    return additionalModelRequestFields;
+};
+export const transformAnthropicAdditionalModelRequestFields = (params, transformInput) => {
+    const additionalModelRequestFields = params.additionalModelRequestFields || params.additional_model_request_fields || {};
+    if (params['top_k']) {
+        additionalModelRequestFields['top_k'] = params['top_k'];
+    }
+    if (params['anthropic_version']) {
+        additionalModelRequestFields['anthropic_version'] = params['anthropic_version'];
+    }
+    const hashedUserId = hashUserId(params['user']);
+    if (hashedUserId) {
+        additionalModelRequestFields['metadata'] = {
+            user_id: hashedUserId,
+        };
+    }
+    if (params['thinking']) {
+        additionalModelRequestFields['thinking'] = params['thinking'];
+    }
+    const mergedAnthropicBetas = resolveAnthropicBetas(mergeAnthropicBetasWithOverride(anthropicBetaResolveFromParamMap(transformInput), params['anthropic_beta']), BEDROCK_CONVERSE_BETA_KEY);
+    if (mergedAnthropicBetas) {
+        additionalModelRequestFields['anthropic_beta'] = mergedAnthropicBetas;
+    }
+    else {
+        delete additionalModelRequestFields['anthropic_beta'];
+    }
+    if (params.tools && params.tools.length) {
+        const anthropicTools = [];
+        const tools = resolveServerTools(params.tools, BEDROCK_CONVERSE_BETA_KEY).tools;
+        tools.forEach((tool) => {
+            if (tool.type !== 'function') {
+                const toolOptions = tool[tool.type];
+                anthropicTools.push({
+                    ...(toolOptions && { ...toolOptions }),
+                    name: tool.type,
+                    type: toolOptions?.name,
+                    ...(tool.cache_control && {
+                        cache_control: { type: 'ephemeral' },
+                    }),
+                });
+            }
+        });
+        if (anthropicTools.length) {
+            additionalModelRequestFields['tools'] = anthropicTools;
+        }
+    }
+    return additionalModelRequestFields;
+};
+export const transformCohereAdditionalModelRequestFields = (params) => {
+    const additionalModelRequestFields = params.additionalModelRequestFields || params.additional_model_request_fields || {};
+    if (params['top_k']) {
+        additionalModelRequestFields['top_k'] = params['top_k'];
+    }
+    if (params['n']) {
+        additionalModelRequestFields['n'] = params['n'];
+    }
+    if (params['frequency_penalty']) {
+        additionalModelRequestFields['frequency_penalty'] = params['frequency_penalty'];
+    }
+    if (params['presence_penalty']) {
+        additionalModelRequestFields['presence_penalty'] = params['presence_penalty'];
+    }
+    if (params['logit_bias']) {
+        additionalModelRequestFields['logitBias'] = params['logit_bias'];
+    }
+    return additionalModelRequestFields;
+};
+export const transformAI21AdditionalModelRequestFields = (params) => {
+    const additionalModelRequestFields = params.additionalModelRequestFields || params.additional_model_request_fields || {};
+    if (params['top_k']) {
+        additionalModelRequestFields['top_k'] = params['top_k'];
+    }
+    if (params['frequency_penalty']) {
+        additionalModelRequestFields['frequencyPenalty'] = {
+            scale: params['frequency_penalty'],
+        };
+    }
+    if (params['presence_penalty']) {
+        additionalModelRequestFields['presencePenalty'] = {
+            scale: params['presence_penalty'],
+        };
+    }
+    if (params['frequencyPenalty']) {
+        additionalModelRequestFields['frequencyPenalty'] = params['frequencyPenalty'];
+    }
+    if (params['presencePenalty']) {
+        additionalModelRequestFields['presencePenalty'] = params['presencePenalty'];
+    }
+    if (params['countPenalty']) {
+        additionalModelRequestFields['countPenalty'] = params['countPenalty'];
+    }
+    return additionalModelRequestFields;
+};
+/**
+ * Gets the gateway role credentials by assuming the role.
+ *
+ * @param tenantName - Tenant name for context
+ * @returns Gateway assumed role credentials, or undefined if gateway credentials are not configured
+ */
+async function getGatewayAssumedRoleCredentials(tenantName, region) {
+    const gatewayAccessKeyId = config.GATEWAY_AWS_USER_ACCESS_KEY_ID;
+    const gatewaySecretAccessKey = config.GATEWAY_AWS_USER_SECRET_ACCESS_KEY;
+    const gatewayRoleArn = config.GATEWAY_AWS_ROLE_ARN;
+    // If gateway credentials are not configured, log and return undefined
+    if (!gatewayAccessKeyId || !gatewaySecretAccessKey || !gatewayRoleArn) {
+        logger.warn(`[getGatewayAssumedRoleCredentials] Gateway credentials not configured for tenant: ${tenantName}`);
+        return undefined;
+    }
+    // Create STS client with gateway user credentials
+    logger.info(`[getGatewayAssumedRoleCredentials] Creating STSClient for gateway user (tenant: ${tenantName})`);
+    const gatewayStsClient = new STSClient({
+        region,
+        credentials: {
+            accessKeyId: gatewayAccessKeyId,
+            secretAccessKey: gatewaySecretAccessKey,
+        },
+    });
+    // Assume the gateway role
+    logger.info(`[getGatewayAssumedRoleCredentials] Attempting to assume role ${gatewayRoleArn} for tenant: ${tenantName}`);
+    const gatewayAssumeRoleCommand = new AssumeRoleCommand({
+        RoleArn: gatewayRoleArn,
+        RoleSessionName: 'GatewayCrossAccountSession',
+    });
+    let gatewayAssumeRoleResponse;
+    try {
+        gatewayAssumeRoleResponse = await gatewayStsClient.send(gatewayAssumeRoleCommand);
+        logger.info(`[getGatewayAssumedRoleCredentials] Successfully assumed role for tenant: ${tenantName}`);
+    }
+    catch (error) {
+        logger.error(`[getGatewayAssumedRoleCredentials] Error assuming gateway role for tenant: ${tenantName}`, error);
+        throw new CredentialResolutionError('Failed to assume gateway role: ' + (error instanceof Error ? error.message : String(error)));
+    }
+    if (!gatewayAssumeRoleResponse.Credentials?.AccessKeyId ||
+        !gatewayAssumeRoleResponse.Credentials?.SecretAccessKey ||
+        !gatewayAssumeRoleResponse.Credentials?.SessionToken) {
+        logger.error(`[getGatewayAssumedRoleCredentials] Invalid credentials received when assuming role for tenant: ${tenantName}`, gatewayAssumeRoleResponse);
+        throw new CredentialResolutionError('Failed to assume gateway role: Invalid credentials received');
+    }
+    // Return credentials directly without caching
+    return {
+        accessKeyId: gatewayAssumeRoleResponse.Credentials.AccessKeyId,
+        secretAccessKey: gatewayAssumeRoleResponse.Credentials.SecretAccessKey,
+        sessionToken: gatewayAssumeRoleResponse.Credentials.SessionToken,
+    };
+}
+function getRoleSessionName(provider) {
+    if (provider === AWS_CLAUDE_PLATFORM) {
+        return 'AWSClaudePlatformSession';
+    }
+    if (provider === AWS_BEDROCK_MANTLE) {
+        return 'AWSBedrockMantleSession';
+    }
+    return 'BedrockSession';
+}
+/**
+ * ================================
+ * Keep this function when syncing from upstream
+ * Our header generation logic is different from the upstream implementation, and depends on this function
+ * ================================
+ */
+export async function getCredentialsFromAssumedRole(session, roleArn, region, externalId, provider) {
+    const tenantName = session.tenantName;
+    const roleSessionName = getRoleSessionName(provider);
+    // Logical key — gateway CachePort adapter prefixes tenant.
+    const hashedKey = createHashedCacheKey(roleArn, region, externalId ?? '');
+    const originalKey = `${provider}-assumed-role-${hashedKey}`;
+    const cacheKey = sanitizeNatsKey(originalKey);
+    const cachedCreds = await getCachedCredentials(cacheKey);
+    if (cachedCreds?.accessKeyId && cachedCreds?.secretAccessKey) {
+        logger.info(`[getCredentialsFromAssumedRole] Found cached credentials for tenant: ${tenantName} and role: ${roleArn}`);
+        return {
+            accessKeyId: cachedCreds.accessKeyId,
+            secretAccessKey: cachedCreds.secretAccessKey,
+            sessionToken: cachedCreds.sessionToken,
+        };
+    }
+    // Try to get gateway credentials (returns undefined if not configured)
+    const gatewayCredentials = await getGatewayAssumedRoleCredentials(tenantName, region);
+    let credentials;
+    let credentialsExpireAt;
+    if (gatewayCredentials) {
+        logger.info(`[getCredentialsFromAssumedRole] Found gateway credentials for tenant: ${tenantName} and role: ${roleArn}`);
+        // Two-step assumption: gateway role → customer role
+        const customerStsClient = new STSClient({
+            region,
+            credentials: {
+                accessKeyId: gatewayCredentials.accessKeyId,
+                secretAccessKey: gatewayCredentials.secretAccessKey,
+                sessionToken: gatewayCredentials.sessionToken,
+            },
+        });
+        const customerAssumeRoleCommand = new AssumeRoleCommand({
+            RoleArn: roleArn,
+            ExternalId: externalId,
+            RoleSessionName: roleSessionName,
+        });
+        let customerAssumeRoleResponse;
+        try {
+            customerAssumeRoleResponse = await customerStsClient.send(customerAssumeRoleCommand);
+        }
+        catch (error) {
+            logger.error(`[getCredentialsFromAssumedRole] Error assuming customer role for tenant: ${tenantName} and role: ${roleArn}`, error);
+            throw new AuthenticationError('Failed to assume customer role: ' + (error instanceof Error ? error.message : String(error)));
+        }
+        if (!customerAssumeRoleResponse.Credentials?.AccessKeyId ||
+            !customerAssumeRoleResponse.Credentials?.SecretAccessKey ||
+            !customerAssumeRoleResponse.Credentials?.SessionToken) {
+            throw new ValidationError('Failed to assume customer role: Invalid credentials received');
+        }
+        credentials = {
+            accessKeyId: customerAssumeRoleResponse.Credentials.AccessKeyId,
+            secretAccessKey: customerAssumeRoleResponse.Credentials.SecretAccessKey,
+            sessionToken: customerAssumeRoleResponse.Credentials.SessionToken,
+        };
+        credentialsExpireAt = customerAssumeRoleResponse.Credentials.Expiration;
+    }
+    else {
+        // Fallback to original direct role assumption using default AWS credentials
+        const stsClient = new STSClient({ region });
+        const assumeRoleCommand = new AssumeRoleCommand({
+            RoleArn: roleArn,
+            ExternalId: externalId,
+            RoleSessionName: roleSessionName,
+        });
+        let assumeRoleResponse;
+        try {
+            assumeRoleResponse = await stsClient.send(assumeRoleCommand);
+        }
+        catch (error) {
+            logger.error(`[getCredentialsFromAssumedRole] Error assuming role for tenant: ${tenantName} and role: ${roleArn}`, error);
+            // The default provider chain found no base AWS credentials for the gateway to
+            // assume the role with. This is a misconfiguration, not an internal error, so
+            // surface it as 403 (mirrors getCredentialsFromRegion) instead of bubbling up as 500.
+            if (error instanceof Error && error.name === 'CredentialsProviderError') {
+                throw new CredentialResolutionError('Unable to retrieve AWS credentials. Configure Bedrock auth (access key, assumed role, or API key) on the model account or guardrail.', { cause: error });
+            }
+            throw new CredentialResolutionError('Failed to assume role: ' + (error instanceof Error ? error.message : String(error)), { cause: error instanceof Error ? error : undefined });
+        }
+        if (!assumeRoleResponse.Credentials?.AccessKeyId ||
+            !assumeRoleResponse.Credentials?.SecretAccessKey ||
+            !assumeRoleResponse.Credentials?.SessionToken) {
+            throw new ValidationError('Failed to assume role: Invalid credentials received');
+        }
+        credentials = {
+            accessKeyId: assumeRoleResponse.Credentials.AccessKeyId,
+            secretAccessKey: assumeRoleResponse.Credentials.SecretAccessKey,
+            sessionToken: assumeRoleResponse.Credentials.SessionToken,
+        };
+        credentialsExpireAt = assumeRoleResponse.Credentials.Expiration;
+    }
+    const expiration = credentialCacheExpiration(credentialsExpireAt?.getTime());
+    await storeCachedCredentials(cacheKey, credentials, expiration, originalKey);
+    return credentials;
+}
+/**
+ * ================================
+ * Keep this function when syncing from upstream
+ * ================================
+ */
+export async function getCredentialsFromRegion(region) {
+    // On multi-tenant hosted gateways the pod's ambient identity is the platform's.
+    // Resolving it here would disclose host credentials to a caller-configured base_url.
+    // {@link SdkInitConfig.allowAmbientCredentials} (bound from LlmGatewaySdk) gates this;
+    // gateway maps `!IS_TFY_SAAS_GATEWAY` into that flag.
+    if (!getAllowAmbientCredentials()) {
+        throw new CredentialResolutionError('Ambient AWS credentials are not available when allowAmbientCredentials is false. ' +
+            'Configure Bedrock auth on the provider account (access key, assumed role, or API key).');
+    }
+    const originalKey = `aws-credentials-${region}`;
+    const cacheKey = sanitizeNatsKey(originalKey);
+    const cachedCreds = await getCachedCredentials(cacheKey);
+    if (cachedCreds?.accessKeyId && cachedCreds?.secretAccessKey) {
+        return cachedCreds;
+    }
+    const stsClient = new STSClient({ region });
+    try {
+        const credentials = await stsClient.config.credentials();
+        if (!credentials) {
+            throw new ValidationError('Unable to retrieve credentials from the default provider chain');
+        }
+        logger.info('fetched credentials from sts default provider chain');
+        const expiration = credentialCacheExpiration(credentials.expiration?.getTime());
+        await storeCachedCredentials(cacheKey, {
+            accessKeyId: credentials.accessKeyId,
+            secretAccessKey: credentials.secretAccessKey,
+            sessionToken: credentials.sessionToken,
+        }, expiration, originalKey);
+        return credentials;
+    }
+    catch (error) {
+        if (error instanceof ValidationError) {
+            throw error;
+        }
+        if (error instanceof Error && error.name === 'CredentialsProviderError') {
+            throw new CredentialResolutionError('Unable to retrieve AWS credentials. Configure Bedrock auth (access key, assumed role, or API key) on the model account or guardrail.', { cause: error });
+        }
+        throw error;
+    }
+}
+export const bedrockFinetuneToOpenAI = (finetune) => {
+    let status = 'running';
+    switch (finetune.status) {
+        case 'Completed':
+            status = 'succeeded';
+            break;
+        case 'Failed':
+            status = 'failed';
+            break;
+        case 'InProgress':
+            status = 'running';
+            break;
+        case 'Stopping':
+        case 'Stopped':
+            status = 'cancelled';
+            break;
+    }
+    return {
+        id: encodeURIComponent(finetune.jobArn),
+        job_name: finetune.jobName,
+        object: 'finetune',
+        status: status,
+        created_at: new Date(finetune.creationTime).getTime(),
+        finished_at: new Date(finetune.endTime).getTime(),
+        fine_tuned_model: finetune.outputModelArn || finetune.outputModelName || finetune.customModelArn,
+        suffix: finetune.customModelName,
+        training_file: encodeURIComponent(finetune?.trainingDataConfig?.s3Uri ?? ''),
+        validation_file: encodeURIComponent(finetune?.validationDataConfig?.s3Uri ?? ''),
+        hyperparameters: {
+            learning_rate_multiplier: Number(finetune?.hyperParameters?.learningRate),
+            batch_size: Number(finetune?.hyperParameters?.batchSize),
+            n_epochs: Number(finetune?.hyperParameters?.epochCount),
+        },
+        error: finetune?.failureMessage ?? {},
+    };
+};
+export const populateHyperParameters = (value) => {
+    let hyperParameters = value.hyperparameters ?? {};
+    if (value.method) {
+        const method = value.method.type;
+        hyperParameters = value.method?.[method]?.hyperparameters ?? {};
+    }
+    return hyperParameters;
+};
+export const getInferenceProfile = async (inferenceProfileIdentifier, aws, session) => {
+    let awsAccessKeyId = aws.awsAccessKeyId || '';
+    let awsSecretAccessKey = aws.awsSecretAccessKey || '';
+    let awsSessionToken = aws.awsSessionToken || '';
+    if (aws.awsAuthType === 'assumedRole') {
+        const credentials = await getCredentialsFromAssumedRole(session, aws.awsRoleArn || '', aws.awsRegion || '', aws.awsExternalId, BEDROCK);
+        awsAccessKeyId = credentials.accessKeyId;
+        awsSecretAccessKey = credentials.secretAccessKey;
+        awsSessionToken = credentials.sessionToken || '';
+    }
+    const awsRegion = aws.awsRegion || 'us-east-1';
+    const url = `https://bedrock.${awsRegion}.amazonaws.com/inference-profiles/${encodeURIComponent(decodeURIComponent(inferenceProfileIdentifier))}`;
+    const headers = await generateAWSHeaders(undefined, { 'content-type': 'application/json' }, url, 'GET', 'bedrock', awsRegion, awsAccessKeyId, awsSecretAccessKey, awsSessionToken);
+    try {
+        const response = await safeFetch(url, { ssrf: 'guard', method: 'GET', headers });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new ValidationError(`Failed to get inference profile: ${response.status} ${response.statusText}: ${body}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        console.error('Error getting inference profile:', error);
+        throw error;
+    }
+};
+const INFERENCE_PROFILE_CACHE_TTL_MS = 86_400_000;
+export const getFoundationModelFromInferenceProfile = async (inferenceProfileIdentifier, aws, session) => {
+    try {
+        const originalKey = `bedrock-inference-profile-${inferenceProfileIdentifier}`;
+        const cacheKey = sanitizeNatsKey(originalKey);
+        const cachedFoundationModel = await getCachedCredentials(cacheKey);
+        if (cachedFoundationModel) {
+            return cachedFoundationModel;
+        }
+        const inferenceProfile = await getInferenceProfile(inferenceProfileIdentifier || '', aws, session);
+        // modelArn is always like arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-v2:1
+        const foundationModel = inferenceProfile?.models?.[0]?.modelArn?.split('/')?.pop() ?? null;
+        if (foundationModel) {
+            await storeCachedCredentials(cacheKey, foundationModel, Date.now() + INFERENCE_PROFILE_CACHE_TTL_MS, originalKey);
+        }
+        return foundationModel;
+    }
+    catch (error) {
+        logger.error(`Error getting foundation model from inference profile error:: ${error}`);
+        return null;
+    }
+};
+export const getBedrockErrorChunk = (id, model) => {
+    return [
+        `data: ${JSON.stringify({
+            id,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            provider: BEDROCK,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        role: 'assistant',
+                        finish_reason: 'stop',
+                    },
+                },
+            ],
+        })}\n\n`,
+        `data: [DONE]\n\n`,
+    ];
+};
+export const getBedrockModelWithoutRegion = (model) => {
+    return model.replace(/^(us\.|eu\.|apac\.|au\.|ca\.|jp\.|global\.)/, '');
+};
+//# sourceMappingURL=utils.js.map