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

package/dist/providers/google-vertex-ai/utils.js

@@ -0,0 +1,1151 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. Remove context as parameter from getAccessToken (it is for cahcing logic supported by upstream hooks, we dont support that yet)
+ * 2. Remove unused vars for linting
+ * 3. Add mistralai, qwen to the provider list in getModelAndProvider and split model string by / instead of .
+ * 4. Refactored JSON Schema transformation for Gemini compatibility with helper function tfyTransformSchemaForGemini (needed because Gemini has stricter schema requirements than standard JSON Schema)
+ *  - Ref: https://github.com/pydantic/pydantic-ai/blob/main/pydantic_ai_slim/pydantic_ai/profiles/google.py
+ * ================================
+ */
+import { GoogleAuth } from 'google-auth-library';
+import { HTTPException } from 'hono/http-exception';
+import { getCachedCredentials, storeCachedCredentials } from '../../cache/port.js';
+import { ValidationError } from '../../errors.js';
+import { BatchEndpoints, fileExtensionMimeTypeMap, GOOGLE_VERTEX_AI } from '../../globals.js';
+import { logger } from '../../logger.js';
+import { createHashedCacheKey, credentialCacheExpiration, credentialCacheExpirationFromExpiresIn, sanitizeNatsKey, } from '../../utils.js';
+import { errorResponse } from '../../utils/errorHandlingUtils.js';
+import { getGoogleAccessToken, importPrivateKey } from '../../utils/jwtUtils.js';
+import { generateErrorResponse } from '../utils.js';
+/**
+ NOTE: Some JWT relatedutil functions have been moved src/utils/jwtUtils.ts instead
+ */
+export const getAccessToken = async (serviceAccountInfo) => {
+    try {
+        if (serviceAccountInfo?.type === 'external_account') {
+            throw new ValidationError('Vertex auth_data is external_account (WIF). Use manifest auth type workload-identity-federation-file with key_file_content, not key-file / service account key path.', { cause: new Error('external_account passed to service account token path') });
+        }
+        // Logical key — gateway CachePort adapter prefixes tenant.
+        const hashedKey = createHashedCacheKey(serviceAccountInfo.client_email, serviceAccountInfo.private_key_id, serviceAccountInfo.private_key);
+        const originalKey = `google-service-account-${hashedKey}`;
+        const cacheKey = sanitizeNatsKey(originalKey);
+        const cachedToken = await getCachedCredentials(cacheKey);
+        if (cachedToken?.access_token) {
+            return cachedToken.access_token;
+        }
+        const { accessToken, expiresIn } = await getGoogleAccessToken(serviceAccountInfo);
+        if (!accessToken) {
+            throw new ValidationError('Vertex: empty access_token from Google OAuth token exchange for service account key. Check key_file_content and token response.', { cause: new Error('getGoogleAccessToken returned empty token') });
+        }
+        const expiration = credentialCacheExpirationFromExpiresIn(expiresIn);
+        await storeCachedCredentials(cacheKey, { access_token: accessToken }, expiration, originalKey);
+        return accessToken;
+    }
+    catch (err) {
+        if (err instanceof ValidationError) {
+            throw err;
+        }
+        const detail = err instanceof Error ? err.message : String(err);
+        logger.error(`[getAccessToken] Failed to obtain access token from service account key: ${detail}`);
+        throw new ValidationError(`Vertex: failed to obtain access token from service account key (${detail}). Verify key_file_content (type service_account, private_key, client_email) and connectivity to Google's OAuth token endpoint.`, { cause: err instanceof Error ? err : undefined });
+    }
+};
+/**
+ * Gets an access token using Application Default Credentials (ADC).
+ * This function uses Google Auth Library's ADC which automatically detects:
+ * - Workload Identity when running in GKE
+ * - Service account keys from GOOGLE_APPLICATION_CREDENTIALS env var
+ * - GCE metadata service when running on GCE
+ * - User credentials when running locally (gcloud auth application-default login)
+ *
+ * @param session - Per-call session (tenantName for cache segregation)
+ * @param vertexProjectId - GCP project ID to include in cache key for proper segregation
+ * @param vertexRegion - GCP region to include in cache key for proper segregation
+ * @param cacheSegment - Optional provider account FQN (or other id) so ADC tokens do not collide across accounts
+ * @returns Access token string
+ */
+export const getAccessTokenFromADC = async (session, vertexProjectId, vertexRegion, cacheSegment) => {
+    try {
+        const tenantName = session.tenantName;
+        // Logical key — gateway CachePort adapter prefixes tenant.
+        const hashedKey = createHashedCacheKey(vertexProjectId, vertexRegion, cacheSegment ?? '');
+        const originalKey = `google-adc-credentials-${hashedKey}`;
+        const cacheKey = sanitizeNatsKey(originalKey);
+        const cachedToken = await getCachedCredentials(cacheKey);
+        if (cachedToken?.access_token) {
+            logger.info(`[getAccessTokenFromADC] Found cached ADC credentials for tenant: ${tenantName}, project: ${vertexProjectId}`);
+            return cachedToken.access_token;
+        }
+        // use GoogleAuth with Application Default Credentials
+        // this will automatically detect Workload Identity in GKE
+        const auth = new GoogleAuth({
+            scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+        });
+        let accessTokenResponse;
+        let expiryDate;
+        try {
+            const client = await auth.getClient();
+            accessTokenResponse = await client.getAccessToken();
+            expiryDate = client.credentials.expiry_date;
+        }
+        catch (error) {
+            logger.error(`[getAccessTokenFromADC] Error getting access token from ADC: ${error instanceof Error ? error.message : String(error)}`);
+            throw new ValidationError(error.message, {
+                cause: error,
+            });
+        }
+        if (!accessTokenResponse.token) {
+            throw new ValidationError('No access token returned from Application Default Credentials', {
+                cause: new Error('No access token returned from Application Default Credentials'),
+            });
+        }
+        const expiration = credentialCacheExpiration(expiryDate);
+        await storeCachedCredentials(cacheKey, { access_token: accessTokenResponse.token }, expiration, originalKey);
+        logger.info(`[getAccessTokenFromADC] Successfully obtained ADC credentials for tenant: ${tenantName}, project: ${vertexProjectId}`);
+        return accessTokenResponse.token;
+    }
+    catch (error) {
+        logger.error(`[getAccessTokenFromADC] Error getting access token from ADC: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+};
+export const getModelAndProvider = (modelString) => {
+    let provider = 'google';
+    let model = modelString;
+    const modelStringParts = modelString.split('/');
+    if (modelStringParts.length > 1) {
+        provider = modelStringParts[0];
+        model = modelStringParts.slice(1).join('.');
+    }
+    return { provider, model };
+};
+export const getMimeType = (url) => {
+    const urlParts = url.split('.');
+    const extension = urlParts[urlParts.length - 1];
+    return fileExtensionMimeTypeMap[extension];
+};
+/**
+ * Maps OpenAI's "detail" parameter to Gemini's "mediaResolution" parameter.
+ *
+ * Translation mapping:
+ * - "low" → "MEDIA_RESOLUTION_LOW"
+ * - "high" → "MEDIA_RESOLUTION_HIGH"
+ * - "auto" or null/undefined → null (omit the field)
+ *
+ * @param detail - Optional string: "low", "high", "auto", or null/undefined
+ * @returns Optional MediaResolution object, or null (to omit the field)
+ */
+export const mapOpenAIDetailToMediaResolution = (detail) => {
+    if (detail === 'low') {
+        return { level: 'MEDIA_RESOLUTION_LOW' };
+    }
+    if (detail === 'high') {
+        return { level: 'MEDIA_RESOLUTION_HIGH' };
+    }
+    // "auto" or null/undefined means let the model decide, so we don't set mediaResolution
+    return null;
+};
+export const GoogleErrorResponseTransform = (response, provider = GOOGLE_VERTEX_AI) => {
+    if ('error' in response) {
+        return generateErrorResponse({
+            message: response.error.message ?? '',
+            type: response.error.status ?? null,
+            code: response.error.status ?? null,
+        }, provider);
+    }
+    return undefined;
+};
+// Extract definition key from a JSON Schema $ref string
+const getDefFromRef = (ref) => {
+    const match = ref.match(/^#\/\$defs\/(.+)$/);
+    return match ? match[1] : null;
+};
+const getDefObject = (defs, key) => key && defs ? defs[key] : undefined;
+// Recursively expands $ref nodes in a JSON Schema object tree
+const DEREFER_MAX_DEPTH = 32;
+const DEREFER_MAX_NODES = 10_000;
+export const derefer = (schema, defs = null, stack = new Set(), depth = 0, budget = { nodes: 0 }) => {
+    if (schema === null || typeof schema !== 'object')
+        return schema;
+    if (depth > DEREFER_MAX_DEPTH || ++budget.nodes > DEREFER_MAX_NODES) {
+        throw new ValidationError('JSON schema $ref expansion exceeds size or depth limits');
+    }
+    if (Array.isArray(schema))
+        return schema.map(item => derefer(item, defs, stack, depth + 1, budget));
+    const node = { ...schema };
+    const activeDefs = defs ?? node.$defs ?? null;
+    if ('$ref' in node && typeof node.$ref === 'string') {
+        const defKey = getDefFromRef(node.$ref);
+        const target = getDefObject(activeDefs, defKey);
+        if (defKey && target) {
+            if (stack.has(defKey))
+                return node;
+            stack.add(defKey);
+            const resolved = derefer(target, activeDefs, stack, depth + 1, budget);
+            stack.delete(defKey);
+            const keys = Object.keys(node);
+            if (keys.length === 1)
+                return resolved;
+            const { $ref: _, ...siblings } = node;
+            for (const key of Object.keys(node))
+                delete node[key];
+            Object.assign(node, resolved, siblings);
+        }
+    }
+    for (const [k, v] of Object.entries(node)) {
+        if (k === '$defs')
+            continue;
+        node[k] = derefer(v, activeDefs, stack, depth + 1, budget);
+    }
+    return node;
+};
+/** Allowed output mime types for Imagen (gen and edit). */
+const IMAGEN_ALLOWED_MIME_TYPES = [fileExtensionMimeTypeMap.png, fileExtensionMimeTypeMap.jpeg];
+/**
+ * Maps OpenAI-style output_format (png | jpeg) and/or mimeType to Vertex mimeType (image/png | image/jpeg).
+ * Prefers output_format when present; falls back to mimeType if allowed. No webp (not OpenAI-compatible).
+ */
+export function toVertexOutputMimeType(outputFormat, mimeType) {
+    if (outputFormat && typeof outputFormat === 'string') {
+        const normalized = outputFormat.trim().toLowerCase();
+        if (normalized === 'png')
+            return fileExtensionMimeTypeMap.png;
+        if (normalized === 'jpeg')
+            return fileExtensionMimeTypeMap.jpeg;
+    }
+    if (mimeType && typeof mimeType === 'string') {
+        const mime = mimeType.trim();
+        if (IMAGEN_ALLOWED_MIME_TYPES.includes(mime))
+            return mime;
+    }
+    return undefined;
+}
+/** Imagen edit: baseSteps (sampling steps) when input_fidelity is 'low'. */
+const IMAGEN_EDIT_BASE_STEPS_LOW_FIDELITY = 35;
+/** Imagen edit: baseSteps (sampling steps) when input_fidelity is high or default. */
+const IMAGEN_EDIT_BASE_STEPS_HIGH_FIDELITY = 75;
+/**
+ * Builds Imagen predict "parameters" that are valid for both image generation and image edit.
+ * Single source of truth for shared params; used by imageGenerate transformParams and image edit transformParametersObject.
+ * Does NOT include gen-only (sampleImageSize, aspectRatio, sampleImageStyle, enhancePrompt) or edit-only (editMode, baseSteps, guidanceScale).
+ * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/imagen-api
+ * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/imagen-api-edit
+ */
+export function buildSharedImagenPredictParams(params) {
+    const config = {};
+    if (params['n'] !== undefined && params['n'] !== null) {
+        config['sampleCount'] = typeof params['n'] === 'number' ? params['n'] : parseInt(String(params['n']), 10);
+    }
+    const outputMime = toVertexOutputMimeType(params['output_format'], params['mimeType']);
+    const outputCompression = params['output_compression'] !== undefined && params['output_compression'] !== null
+        ? typeof params['output_compression'] === 'number'
+            ? params['output_compression']
+            : parseInt(String(params['output_compression']), 10)
+        : undefined;
+    if (outputMime !== undefined || (outputCompression !== undefined && !Number.isNaN(outputCompression))) {
+        if (!config['outputOptions'] || typeof config['outputOptions'] !== 'object') {
+            config['outputOptions'] = {};
+        }
+        const outputOptions = config['outputOptions'];
+        if (outputMime !== undefined)
+            outputOptions['mimeType'] = outputMime;
+        if (outputCompression !== undefined && !Number.isNaN(outputCompression)) {
+            outputOptions['compressionQuality'] = Math.min(100, Math.max(0, outputCompression));
+        }
+    }
+    // Vertex Imagen: seed is not supported when addWatermark is true (per API docs).
+    if (params['add_watermark'] === true && params['seed'] !== undefined && params['seed'] !== null) {
+        throw new HTTPException(400, {
+            message: 'Seed is not supported when add_watermark is true. Omit seed or set add_watermark to false.',
+        });
+    }
+    if (params['seed'] !== undefined && params['seed'] !== null) {
+        config['seed'] = params['seed'];
+    }
+    if (params['negativePrompt'] &&
+        typeof params['negativePrompt'] === 'string' &&
+        params['negativePrompt'].trim()) {
+        config['negativePrompt'] = params['negativePrompt'].trim();
+    }
+    const personGen = params['person_generation'];
+    if (personGen && typeof personGen === 'string' && personGen.trim()) {
+        config['personGeneration'] = personGen.trim();
+    }
+    const safetySetting = params['safety_setting'] ?? params['safetySetting'];
+    if (safetySetting !== undefined && safetySetting !== null && String(safetySetting).trim() !== '') {
+        config['safetySetting'] = String(safetySetting).trim();
+    }
+    if (typeof params['add_watermark'] === 'boolean') {
+        config['addWatermark'] = params['add_watermark'];
+    }
+    const languageRaw = params['language'];
+    if (languageRaw && typeof languageRaw === 'string' && languageRaw.trim()) {
+        config['language'] = languageRaw.trim();
+    }
+    const storageUriRaw = params['storage_uri'];
+    if (storageUriRaw && typeof storageUriRaw === 'string' && storageUriRaw.trim()) {
+        config['storageUri'] = storageUriRaw.trim();
+    }
+    const includeRaiReasonRaw = params['include_rai_reason'] ?? params['includeRaiReason'];
+    if (typeof includeRaiReasonRaw === 'boolean') {
+        config['includeRaiReason'] = includeRaiReasonRaw;
+    }
+    if (typeof params['include_safety_attributes'] === 'boolean') {
+        config['includeSafetyAttributes'] = params['include_safety_attributes'];
+    }
+    return config;
+}
+export const transformParametersObject = (params) => {
+    // Edit-only params (not valid for generation)
+    const parameters = {};
+    if (params.editMode) {
+        parameters.editMode = params.editMode;
+    }
+    else if (params.mask) {
+        parameters.editMode = 'EDIT_MODE_INPAINT_INSERTION';
+    }
+    if (params.input_fidelity) {
+        parameters.editConfig = {};
+        parameters.editConfig.baseSteps =
+            params.input_fidelity === 'low' ? IMAGEN_EDIT_BASE_STEPS_LOW_FIDELITY : IMAGEN_EDIT_BASE_STEPS_HIGH_FIDELITY;
+    }
+    const baseStepsValue = params.baseSteps ?? params.base_steps;
+    if (baseStepsValue !== undefined && baseStepsValue !== null) {
+        parameters.baseSteps = parseInt(String(baseStepsValue), 10);
+    }
+    const guidanceScaleRaw = params.guidance_scale ?? params.guidanceScale;
+    if (guidanceScaleRaw !== undefined && guidanceScaleRaw !== null) {
+        const parsed = parseInt(String(guidanceScaleRaw), 10);
+        if (!Number.isNaN(parsed))
+            parameters.guidanceScale = parsed;
+    }
+    // Merge shared Imagen predict params (gen + edit)
+    Object.assign(parameters, buildSharedImagenPredictParams(params));
+    return parameters;
+};
+export const transformInstancesObject = (params) => {
+    const instances = [{}];
+    // Initialize the structure
+    instances[0].referenceImages = [];
+    if (params.prompt) {
+        instances[0].prompt = params.prompt;
+    }
+    // Handle images (single or array)
+    if (Array.isArray(params.image)) {
+        for (const [index, image] of params.image.entries()) {
+            const imageObject = {
+                referenceType: 'REFERENCE_TYPE_RAW',
+                referenceId: index + 1,
+                referenceImage: {
+                    bytesBase64Encoded: image,
+                },
+            };
+            instances[0].referenceImages.push(imageObject);
+        }
+    }
+    else if (params.image) {
+        const imageObject = {
+            referenceType: 'REFERENCE_TYPE_RAW',
+            referenceId: 1,
+            referenceImage: {
+                bytesBase64Encoded: params.image,
+            },
+        };
+        instances[0].referenceImages.push(imageObject);
+    }
+    // Handle mask
+    if (params.mask) {
+        const nextReferenceId = instances[0].referenceImages.length + 1;
+        const maskObject = {
+            referenceType: 'REFERENCE_TYPE_MASK',
+            referenceId: nextReferenceId, // Next ID after images
+            referenceImage: {
+                bytesBase64Encoded: params.mask,
+            },
+        };
+        // ALWAYS add maskImageConfig when mask is present (required by Vertex AI)
+        maskObject.maskImageConfig = {};
+        // Set maskMode (default to USER_PROVIDED if not specified)
+        maskObject.maskImageConfig.maskMode = params.maskMode || 'MASK_MODE_USER_PROVIDED';
+        // Add optional fields
+        if (params.maskClasses) {
+            let maskClasses = params.maskClasses;
+            // Parse JSON string back to array (from imageEdit.ts preprocessing)
+            if (typeof maskClasses === 'string') {
+                maskClasses = JSON.parse(maskClasses);
+            }
+            maskObject.maskImageConfig.maskClasses = maskClasses;
+        }
+        if (params.dilation !== undefined) {
+            maskObject.maskImageConfig.dilation = parseFloat(params.dilation);
+        }
+        instances[0].referenceImages.push(maskObject);
+    }
+    return instances;
+};
+const stripUnresolvedRefs = (node) => {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        node.forEach(stripUnresolvedRefs);
+        return;
+    }
+    delete node.$ref;
+    for (const value of Object.values(node))
+        stripUnresolvedRefs(value);
+};
+export const transformGeminiToolParameters = (parameters) => {
+    if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)) {
+        return parameters;
+    }
+    const schema = derefer(parameters);
+    delete schema.$defs;
+    stripUnresolvedRefs(schema);
+    const isNullTypeNode = (node) => node && typeof node === 'object' && node.type === 'null';
+    // Vertex has no `const`, and its `enum` is string-only — non-string constants can only
+    // be preserved in `description`.
+    const applyConst = (node, transformed) => {
+        const value = node.const;
+        if (value === undefined || transformed.enum !== undefined)
+            return;
+        if (typeof value === 'string') {
+            if (transformed.type === undefined)
+                transformed.type = 'string';
+            transformed.enum = [value];
+            return;
+        }
+        const note = `Must be exactly: ${JSON.stringify(value)}`;
+        transformed.description = transformed.description ? `${transformed.description} (${note})` : note;
+    };
+    const transformNode = (node) => {
+        if (Array.isArray(node)) {
+            return node.map(transformNode);
+        }
+        if (!node || typeof node !== 'object')
+            return node;
+        const transformed = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'const')
+                continue; // applied after the loop, needs the final type/description
+            if ((key === 'anyOf' || key === 'oneOf') && Array.isArray(value)) {
+                const nonNullItems = value.filter(item => !isNullTypeNode(item));
+                const hadNull = nonNullItems.length < value.length;
+                if (nonNullItems.length === 1 && hadNull) {
+                    // Flatten to single schema: get rid of anyOf/oneOf and set nullable: true
+                    const single = transformNode(nonNullItems[0]);
+                    if (single && typeof single === 'object') {
+                        Object.assign(transformed, single);
+                        transformed.nullable = true;
+                    }
+                    continue;
+                }
+                transformed[key] = transformNode(hadNull ? nonNullItems : value);
+                if (hadNull)
+                    transformed.nullable = true;
+                continue;
+            }
+            transformed[key] = transformNode(value);
+        }
+        applyConst(node, transformed);
+        const typeVal = transformed.type;
+        const isArray = (typeof typeVal === 'string' && typeVal.toLowerCase() === 'array') ||
+            (Array.isArray(typeVal) && typeVal.some(t => typeof t === 'string' && t.toLowerCase() === 'array'));
+        if (isArray) {
+            const items = transformed.items;
+            const missingItems = items == null || (typeof items === 'object' && !Array.isArray(items) && Object.keys(items).length === 0);
+            if (missingItems)
+                transformed.items = { type: 'object' };
+        }
+        return transformed;
+    };
+    return transformNode(schema);
+};
+// Strip JSON Schema fields unsupported by Google/Vertex AI from tool parameters and structured output schemas.
+// Supported fields: https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/Schema
+export const recursivelyDeleteUnsupportedParameters = (obj) => {
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj))
+        return;
+    delete obj.additional_properties;
+    delete obj.additionalProperties;
+    delete obj['$schema'];
+    delete obj.propertyNames;
+    delete obj.patternProperties;
+    delete obj['$id'];
+    delete obj['$comment'];
+    delete obj.dependencies;
+    delete obj.dependentRequired;
+    delete obj.dependentSchemas;
+    delete obj.unevaluatedProperties;
+    delete obj.unevaluatedItems;
+    delete obj.exclusiveMinimum;
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith('x-'))
+            delete obj[key];
+    }
+    for (const key in obj) {
+        if (obj[key] !== null && typeof obj[key] === 'object') {
+            recursivelyDeleteUnsupportedParameters(obj[key]);
+        }
+        if (key == 'anyOf' && Array.isArray(obj[key])) {
+            obj[key].forEach((item) => {
+                recursivelyDeleteUnsupportedParameters(item);
+            });
+        }
+    }
+};
+// Generate Gateway specific response.
+export const GoogleResponseHandler = (response, status) => {
+    if (status !== 200) {
+        const message = response instanceof Response
+            ? `Request failed with status ${response.status}`
+            : typeof response === 'string'
+                ? response
+                : JSON.stringify(response);
+        const body = {
+            status: 'failure',
+            message,
+            error: { message, type: null, code: String(status || 500) },
+            provider: GOOGLE_VERTEX_AI,
+        };
+        return errorResponse(body, status || 500);
+    }
+    if (!(response instanceof Response)) {
+        const _response = typeof response === 'object' ? JSON.stringify(response) : response;
+        return new Response(_response, {
+            status: status || 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    return response;
+};
+export const googleBatchStatusToOpenAI = (status) => {
+    switch (status) {
+        case 'JOB_STATE_CANCELLING':
+            return 'cancelling';
+        case 'JOB_STATE_CANCELLED':
+            return 'cancelled';
+        case 'JOB_STATE_EXPIRED':
+            return 'expired';
+        case 'JOB_STATE_FAILED':
+            return 'failed';
+        case 'JOB_STATE_PARTIALLY_SUCCEEDED':
+        case 'JOB_STATE_SUCCEEDED':
+            return 'completed';
+        case 'JOB_STATE_RUNNING':
+        case 'JOB_STATE_UPDATING':
+            return 'in_progress';
+        case 'JOB_STATE_PAUSED':
+        case 'JOB_STATE_PENDING':
+        case 'JOB_STATE_QUEUED':
+        case 'JOB_STATE_UNSPECIFIED':
+        default:
+            return 'validating';
+    }
+};
+export const googleFinetuneStatusToOpenAI = (status) => {
+    switch (status) {
+        case 'JOB_STATE_CANCELLED':
+        case 'JOB_STATE_CANCELLING':
+        case 'JOB_STATE_EXPIRED':
+            return 'cancelled';
+        case 'JOB_STATE_FAILED':
+            return 'failed';
+        case 'JOB_STATE_PARTIALLY_SUCCEEDED':
+        case 'JOB_STATE_SUCCEEDED':
+            return 'succeeded';
+        case 'JOB_STATE_PAUSED':
+        case 'JOB_STATE_PENDING':
+        case 'JOB_STATE_QUEUED':
+            return 'queued';
+        case 'JOB_STATE_RUNNING':
+        case 'JOB_STATE_UPDATING':
+            return 'running';
+        case 'JOB_STATE_UNSPECIFIED':
+            return 'queued';
+        default:
+            return 'queued';
+    }
+};
+const getTimeKey = (status, value) => {
+    if (status === 'JOB_STATE_FAILED') {
+        return { failed_at: new Date(value).getTime() };
+    }
+    if (status === 'JOB_STATE_SUCCEEDED') {
+        return { completed_at: new Date(value).getTime() };
+    }
+    if (status === 'JOB_STATE_CANCELLED') {
+        return { cancelled_at: new Date(value).getTime() };
+    }
+    if (status === 'JOB_STATE_EXPIRED') {
+        return { failed_at: new Date(value).getTime() };
+    }
+    return {};
+};
+export const GoogleToOpenAIBatch = (response) => {
+    const jobId = response.name.split('/').at(-1);
+    const total = Object.values(response.completionStats ?? {}).reduce((acc, current) => acc + Number.parseInt(current), 0);
+    const endpoint = isEmbeddingModel(response.model) ? BatchEndpoints.EMBEDDINGS : BatchEndpoints.CHAT_COMPLETIONS;
+    const fileSuffix = endpoint === BatchEndpoints.EMBEDDINGS ? '000000000000.jsonl' : 'predictions.jsonl';
+    const outputFileId = response.outputInfo
+        ? `${response.outputInfo?.gcsOutputDirectory}/${fileSuffix}`
+        : response.outputConfig.gcsDestination.outputUriPrefix;
+    return {
+        id: jobId,
+        object: 'batch',
+        endpoint: endpoint,
+        input_file_id: encodeURIComponent(response.inputConfig.gcsSource?.uris?.at(0) ?? ''),
+        completion_window: null,
+        status: googleBatchStatusToOpenAI(response.state),
+        output_file_id: encodeURIComponent(outputFileId),
+        // Same as output_file_id
+        error_file_id: encodeURIComponent(response.outputConfig.gcsDestination.outputUriPrefix ?? ''),
+        created_at: new Date(response.createTime).getTime(),
+        ...getTimeKey(response.state, response.endTime),
+        in_progress_at: new Date(response.startTime).getTime(),
+        ...getTimeKey(response.state, response.updateTime),
+        request_counts: {
+            total: total,
+            completed: response.completionStats?.successfulCount,
+            failed: response.completionStats?.failedCount,
+        },
+        ...(response.error && {
+            errors: {
+                object: 'list',
+                data: [response.error],
+            },
+        }),
+    };
+};
+export const transformVertexLogprobs = (generation) => {
+    const logprobsContent = [];
+    if (!generation.logprobsResult)
+        return null;
+    if (generation.logprobsResult?.chosenCandidates) {
+        generation.logprobsResult.chosenCandidates.forEach(candidate => {
+            const bytes = [];
+            for (const char of candidate.token) {
+                bytes.push(char.charCodeAt(0));
+            }
+            logprobsContent.push({
+                token: candidate.token,
+                logprob: candidate.logProbability,
+                bytes: bytes,
+            });
+        });
+    }
+    if (generation.logprobsResult?.topCandidates) {
+        generation.logprobsResult.topCandidates.forEach((topCandidatesForIndex, index) => {
+            const topLogprobs = [];
+            for (const candidate of topCandidatesForIndex.candidates) {
+                const bytes = [];
+                for (const char of candidate.token) {
+                    bytes.push(char.charCodeAt(0));
+                }
+                topLogprobs.push({
+                    token: candidate.token,
+                    logprob: candidate.logProbability,
+                    bytes: bytes,
+                });
+            }
+            logprobsContent[index].top_logprobs = topLogprobs;
+        });
+    }
+    return logprobsContent;
+};
+const populateHyperparameters = (value) => {
+    let hyperParameters = value.hyperparameters ?? {};
+    if (value.method) {
+        const method = value.method.type;
+        hyperParameters = value.method?.[method]?.hyperparameters ?? {};
+    }
+    return {
+        epochCount: hyperParameters?.n_epochs,
+        learningRateMultiplier: hyperParameters?.learning_rate_multiplier,
+        adapterSize: hyperParameters?.batch_size,
+    };
+};
+export const transformVertexFinetune = (params) => {
+    const parameterSpec = {
+        training_dataset_uri: decodeURIComponent(params['training_file'] ?? ''),
+        ...(params['validation_file'] && {
+            validation_dataset_uri: decodeURIComponent(params['validation_file']),
+        }),
+        hyperParameters: populateHyperparameters(params),
+    };
+    return parameterSpec;
+};
+export const getBucketAndFile = (uri) => {
+    if (!uri)
+        return { bucket: '', file: '' };
+    let _url = decodeURIComponent(uri);
+    _url = _url.replaceAll('gs://', '');
+    const parts = _url.split('/');
+    const bucket = parts[0];
+    const file = parts.slice(1).join('/');
+    return { bucket, file };
+};
+export const GoogleToOpenAIFinetune = (response) => {
+    return {
+        id: response.name.split('/').at(-1),
+        object: 'finetune',
+        status: googleFinetuneStatusToOpenAI(response.state),
+        created_at: new Date(response.createTime).getTime(),
+        error: response.error,
+        fine_tuned_model: response.tunedModel?.model,
+        ...(response.endTime && {
+            finished_at: new Date(response.endTime).getTime(),
+        }),
+        hyperparameters: {
+            batch_size: response.supervisedTuningSpec.hyperParameters?.adapterSize,
+            learning_rate_multiplier: response.supervisedTuningSpec.hyperParameters.learningRateMultiplier,
+            n_epochs: response.supervisedTuningSpec.hyperParameters.epochCount,
+        },
+        model: response.baseModel ?? response.source_model?.baseModel,
+        trained_tokens: response.tuningDataStats?.supervisedTuningDataStats.totalBillableTokenCount,
+        training_file: encodeURIComponent(response.supervisedTuningSpec.trainingDatasetUri),
+        ...(response.supervisedTuningSpec.validationDatasetUri && {
+            validation_file: encodeURIComponent(response.supervisedTuningSpec.validationDatasetUri),
+        }),
+        ...(response.tunedModelDisplayName && {
+            suffix: response.tunedModelDisplayName,
+        }),
+    };
+};
+export const vertexRequestLineHandler = (purpose, vertexBatchEndpoint, transformedBody, requestId) => {
+    switch (purpose) {
+        case 'batch':
+            return vertexBatchEndpoint === BatchEndpoints.EMBEDDINGS
+                ? { ...transformedBody, requestId: requestId }
+                : { request: transformedBody, requestId: requestId };
+        case 'fine-tune':
+            return transformedBody;
+    }
+};
+export const isEmbeddingModel = (modelName) => {
+    return modelName.includes('embedding');
+};
+export const generateSignedURL = async (serviceAccountInfo, bucketName, objectName, expiration = 604800, httpMethod = 'GET', queryParameters = {}, headers = {}) => {
+    if (expiration > 604800) {
+        throw new Error("Expiration Time can't be longer than 604800 seconds (7 days).");
+    }
+    const escapedObjectName = encodeURIComponent(objectName).replace(/%2F/g, '/');
+    const canonicalUri = `/${escapedObjectName}`;
+    const datetimeNow = new Date();
+    const requestTimestamp = datetimeNow
+        .toISOString()
+        .replace(/[-:]/g, '') // Remove hyphens and colons
+        .replace(/\.\d{3}Z$/, 'Z'); // Remove milliseconds and ensure Z at end
+    const datestamp = datetimeNow.toISOString().slice(0, 10).replace(/-/g, '');
+    const clientEmail = serviceAccountInfo.client_email;
+    const credentialScope = `${datestamp}/auto/storage/goog4_request`;
+    const credential = `${clientEmail}/${credentialScope}`;
+    const host = `${bucketName}.storage.googleapis.com`;
+    headers['host'] = host;
+    // Create canonical headers
+    let canonicalHeaders = '';
+    const orderedHeaders = Object.keys(headers).sort();
+    for (const key of orderedHeaders) {
+        const lowerKey = key.toLowerCase();
+        const value = headers[key].toLowerCase();
+        canonicalHeaders += `${lowerKey}:${value}\n`;
+    }
+    // Create signed headers
+    const signedHeaders = orderedHeaders.map(key => key.toLowerCase()).join(';');
+    // Add required query parameters
+    const queryParams = {
+        ...queryParameters,
+        'X-Goog-Algorithm': 'GOOG4-RSA-SHA256',
+        'X-Goog-Credential': credential,
+        'X-Goog-Date': requestTimestamp,
+        'X-Goog-Expires': expiration.toString(),
+        'X-Goog-SignedHeaders': signedHeaders,
+    };
+    // Create canonical query string
+    const canonicalQueryString = Object.keys(queryParams)
+        .sort()
+        .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`)
+        .join('&');
+    // Create canonical request
+    const canonicalRequest = [
+        httpMethod,
+        canonicalUri,
+        canonicalQueryString,
+        canonicalHeaders,
+        signedHeaders,
+        'UNSIGNED-PAYLOAD',
+    ].join('\n');
+    // Hash the canonical request
+    const canonicalRequestHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonicalRequest));
+    // Create string to sign
+    const stringToSign = [
+        'GOOG4-RSA-SHA256',
+        requestTimestamp,
+        credentialScope,
+        Array.from(new Uint8Array(canonicalRequestHash))
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join(''),
+    ].join('\n');
+    // Sign the string
+    const privateKey = await importPrivateKey(serviceAccountInfo.private_key);
+    const signature = await crypto.subtle.sign({
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: { name: 'SHA-256' },
+    }, privateKey, new TextEncoder().encode(stringToSign));
+    // Convert signature to hex
+    const signatureHex = Array.from(new Uint8Array(signature))
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+    // Construct the final URL
+    const schemeAndHost = `https://${host}`;
+    return `${schemeAndHost}${canonicalUri}?${canonicalQueryString}&x-goog-signature=${signatureHex}`;
+};
+/**
+ * Transforms Gemini API request body to Vertex AI format
+ * Removes the 'id' field from functionResponse AND functionCall objects, as
+ * Vertex AI rejects it ("Unknown name \"id\" ... Cannot find field").
+ *
+ * Gemini API format: functionResponse: { id, name, response }, functionCall: { id, name, args }
+ * Vertex AI format:  functionResponse: { name, response },      functionCall: { name, args }
+ *
+ * @param inputParams The request parameters to transform
+ */
+export const transformGeminiToVertexRequestBody = (inputParams) => {
+    if (inputParams && typeof inputParams === 'object' && 'contents' in inputParams) {
+        const params = inputParams;
+        if (params.contents) {
+            params.contents = params.contents.map((content) => {
+                if (content.parts) {
+                    content.parts = content.parts.map((part) => {
+                        // Remove 'id' field from functionResponse - Vertex AI doesn't accept it
+                        if (part.functionResponse && part.functionResponse.id) {
+                            const { id: _id, ...restOfFunctionResponse } = part.functionResponse;
+                            return { ...part, functionResponse: restOfFunctionResponse };
+                        }
+                        if (part.functionCall && part.functionCall.id) {
+                            const { id: _id, ...restOfFunctionCall } = part.functionCall;
+                            return { ...part, functionCall: restOfFunctionCall };
+                        }
+                        return part;
+                    });
+                }
+                return content;
+            });
+        }
+    }
+};
+export const OPENAI_AUDIO_FORMAT_TO_VERTEX_MIME_TYPE_MAPPING = {
+    mp3: 'audio/mp3',
+    wav: 'audio/wav',
+    opus: 'audio/ogg',
+    flac: 'audio/flac',
+    pcm16: 'audio/pcm',
+    'x-aac': 'audio/aac',
+    'x-m4a': 'audio/m4a',
+    mpeg: 'audio/mpeg',
+    mpga: 'audio/mpga',
+    mp4: 'audio/mp4',
+    webm: 'audio/webm',
+};
+export const transformInputAudioPart = (c) => {
+    const data = c.input_audio?.data;
+    const mimeType = OPENAI_AUDIO_FORMAT_TO_VERTEX_MIME_TYPE_MAPPING[c.input_audio?.format];
+    return {
+        inlineData: {
+            data: data ?? '',
+            mimeType,
+        },
+    };
+};
+export const googleTools = [
+    'googleSearch',
+    'google_search',
+    'googleSearchRetrieval',
+    'google_search_retrieval',
+    'computerUse',
+    'computer_use',
+];
+/**
+ * Transforms an OpenAI-style `{ type: "computer_use", ... }` tool into the
+ * Gemini API format `{ computerUse: { environment, excludedPredefinedFunctions } }`.
+ */
+export function transformComputerUseToolFromOpenAI(tool) {
+    const envMapping = {
+        browser: 'ENVIRONMENT_BROWSER',
+        unspecified: 'ENVIRONMENT_UNSPECIFIED',
+        ENVIRONMENT_BROWSER: 'ENVIRONMENT_BROWSER',
+        ENVIRONMENT_UNSPECIFIED: 'ENVIRONMENT_UNSPECIFIED',
+    };
+    const computerUseConfig = {};
+    if (tool.environment != null) {
+        const mapped = envMapping[tool.environment];
+        if (mapped) {
+            computerUseConfig.environment = mapped;
+        }
+    }
+    if (tool.excluded_predefined_functions != null) {
+        computerUseConfig.excludedPredefinedFunctions = tool.excluded_predefined_functions;
+    }
+    else if (tool.excludedPredefinedFunctions != null) {
+        computerUseConfig.excludedPredefinedFunctions = tool.excludedPredefinedFunctions;
+    }
+    return { computerUse: computerUseConfig };
+}
+export const transformGoogleTools = (tool) => {
+    const tools = [];
+    if (['googleSearch', 'google_search'].includes(tool.function.name)) {
+        const timeRangeFilter = tool.function.parameters?.timeRangeFilter;
+        tools.push({
+            googleSearch: {
+                // allow null
+                ...(timeRangeFilter !== undefined && { timeRangeFilter }),
+            },
+        });
+    }
+    else if (['googleSearchRetrieval', 'google_search_retrieval'].includes(tool.function.name)) {
+        tools.push(buildGoogleSearchRetrievalTool(tool));
+    }
+    else if (['computerUse', 'computer_use'].includes(tool.function.name)) {
+        tools.push({
+            computerUse: {
+                environment: tool.function.parameters?.environment,
+                excludedPredefinedFunctions: tool.function.parameters?.excluded_predefined_functions,
+            },
+        });
+    }
+    return tools;
+};
+export const buildGoogleSearchRetrievalTool = (tool) => {
+    const googleSearchRetrievalTool = {
+        googleSearchRetrieval: {},
+    };
+    if (tool.function.parameters?.dynamicRetrievalConfig) {
+        googleSearchRetrievalTool.googleSearchRetrieval.dynamicRetrievalConfig =
+            tool.function.parameters.dynamicRetrievalConfig;
+    }
+    return googleSearchRetrievalTool;
+};
+/**
+ * Thinking support in Google Gemini models (as of 2026):
+ *
+ * thinkingLevel (Gemini 3+):
+ *   gemini-3-flash-preview, gemini-3-pro-image-preview, gemini-3.1-pro-preview,
+ *   gemini-3.1-flash-lite-preview, gemini-3.1-flash-image-preview, etc.
+ *
+ * thinkingBudget (Gemini 2.5 + special models):
+ *   gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite,
+ *   gemini-2.5-flash-native-audio-*, gemini-robotics-er-1.5-preview,
+ *   gemini-2.0-flash-thinking-exp (deprecated experimental)
+ *
+ * No thinking support:
+ *   gemini-2.0-flash, gemini-2.0-flash-lite, gemini-1.5-*, gemini-1.0-*,
+ *   gemini-exp-*, gemma-*, learnlm-*
+ *
+ * Unversioned aliases (gemini-flash-lite-latest, gemini-pro-latest, etc.)
+ * resolve to 2.5+ and DO support thinking (thinkingBudget).
+ *
+ * @see https://ai.google.dev/gemini-api/docs/thinking
+ * @see https://firebase.google.com/docs/ai-logic/thinking
+ */
+const extractModelName = (modelName) => {
+    if (!modelName)
+        return '';
+    return modelName.includes('/') ? (modelName.split('/').pop() ?? '') : modelName;
+};
+/**
+ * Models that support thinking despite matching a NO_THINKING_SUPPORT prefix.
+ * gemini-2.0-flash-thinking-exp uses thinkingBudget even though the broader
+ * gemini-2.0 family does not support thinking.
+ */
+const THINKING_SUPPORT_EXCEPTIONS = ['gemini-2.0-flash-thinking'];
+/**
+ * Model prefixes that do NOT support ANY form of thinking config.
+ * Sending thinkingConfig to these models will cause a 400 error.
+ */
+const NO_THINKING_SUPPORT_PREFIXES = [
+    'gemini-2.0',
+    'gemini-1.',
+    'gemini-exp',
+    'gemini-gemma',
+    'gemini-embed',
+    'gemma',
+    'learnlm',
+];
+/**
+ * Returns true when the model supports any form of thinking configuration
+ * (either `thinkingLevel` for Gemini 3+ or `thinkingBudget` for Gemini 2.5).
+ *
+ * Returns false for models that don't support thinking at all (most Gemini 2.0,
+ * Gemini 1.x, experimental models, gemma, learnlm).
+ * For these, `reasoning_effort` / `thinking` params should be silently dropped.
+ */
+export const supportsThinking = (modelName) => {
+    const actual = extractModelName(modelName);
+    if (!actual)
+        return false;
+    if (THINKING_SUPPORT_EXCEPTIONS.some(prefix => actual.startsWith(prefix)))
+        return true;
+    return !NO_THINKING_SUPPORT_PREFIXES.some(prefix => actual.startsWith(prefix));
+};
+/**
+ * Model prefixes that do NOT support the `thinkingLevel` enum API.
+ * These either use the integer `thinkingBudget` (gemini-2.5.x, gemini-robotics,
+ * gemini-2.0-flash-thinking) or don't support thinking at all.
+ *
+ * Everything not matched here (gemini-3+, future generations) defaults to thinkingLevel.
+ */
+const NON_THINKING_LEVEL_MODEL_PREFIXES = [
+    'gemini-2.',
+    'gemini-1.',
+    'gemini-pro',
+    'gemini-flash',
+    'gemini-exp',
+    'gemini-robotics',
+    'gemini-3-pro-image',
+];
+/**
+ * Returns true when the model uses the `thinkingLevel` enum API (Gemini 3+).
+ * Returns false for models that use `thinkingBudget` (Gemini 2.5, gemini-robotics)
+ * or don't support thinking at all.
+ *
+ * IMPORTANT: Only call this after confirming `supportsThinking()` is true,
+ * otherwise a non-thinking model will fall into the `thinkingBudget` path.
+ */
+export const supportsThinkingLevel = (modelName) => {
+    const actual = extractModelName(modelName);
+    if (!actual)
+        return false;
+    return !NON_THINKING_LEVEL_MODEL_PREFIXES.some(prefix => actual.startsWith(prefix));
+};
+/**
+ * Returns the Google-recommended dummy thought signature for Gemini 3+ models.
+ *
+ * When a multi-turn conversation contains tool calls that have no `thoughtSignature`
+ * (e.g. they were generated by an older model or by a non-Gemini provider), Gemini 3+
+ * models require a placeholder to bypass their signature validator. Google explicitly
+ * documents `base64("skip_thought_signature_validator")` as the bypass value:
+ * https://ai.google.dev/gemini-api/docs/thought-signatures#faqs
+ *
+ * Only inject this for Gemini 3+ (check via `supportsThinkingLevel`). Older models do
+ * not need or understand `thoughtSignature` at all.
+ */
+export const getDummyThoughtSignature = () => {
+    return btoa('skip_thought_signature_validator');
+};
+/**
+ * Returns true if the model is a Gemini 3 Flash variant.
+ * Gemini 3 Flash supports `thinkingLevel: "minimal"` while other Gemini 3 models
+ * only support `"low"` and above.
+ */
+export const isGemini3Flash = (modelName) => {
+    const actualModelName = modelName.includes('/') ? (modelName.split('/').pop() ?? '') : modelName;
+    return actualModelName.startsWith('gemini-3') && actualModelName.includes('flash');
+};
+/**
+ * Builds the thinkingConfig object for Gemini 3+ models that use thinkingLevel.
+ *
+ * Maps OpenAI-compatible `reasoning_effort` strings to the `thinkingLevel` values
+ * accepted by the Gemini API:
+ * - "minimal" → "minimal" for Flash, "low" for other Gemini 3 models (Gemini 3 Pro/Ultra
+ *   do not support the "minimal" level)
+ * - "low"     → "low"
+ * - "medium"  → "medium"
+ * - "high"    → "high"
+ * - "none" / "disable" → { thinkingLevel: "minimal"/"low", includeThoughts: false }
+ *
+ * Centralizes the contract so both Google AI Studio and Vertex AI providers stay in sync.
+ */
+export const buildGeminiThinkingConfig = (reasoningEffort, model = '') => {
+    const isFlash = isGemini3Flash(model);
+    // gemini-3.1-pro-preview accepts "medium" directly (same as Flash variants).
+    const isGemini31Pro = model.includes('gemini-3.1-pro') || model.includes('gemini-3-1-pro');
+    const disable = reasoningEffort === 'none';
+    let level;
+    if (disable) {
+        // Disabled: use the lowest valid level but set includeThoughts: false.
+        level = isFlash ? 'minimal' : 'low';
+    }
+    else if (reasoningEffort === 'minimal') {
+        // "minimal" is only valid for Flash; non-Flash models use "low" as the floor.
+        level = isFlash ? 'minimal' : 'low';
+    }
+    else if (reasoningEffort === 'medium' && !isFlash && !isGemini31Pro) {
+        level = 'high';
+    }
+    else {
+        level = reasoningEffort;
+    }
+    return { thinkingLevel: level, includeThoughts: !disable };
+};
+/**
+ * Maps an Anthropic-style `budget_tokens` value to the nearest Gemini 3 `thinkingLevel`.
+ *
+ * Gemini 3 does not accept `thinkingBudget`; it uses a semantic level enum instead.
+ * There is no official Google mapping, so we derive reasonable thresholds from
+ * Gemini 2.5 Pro's documented budget range (128–32 768, default 8 192):
+ *
+ *   Flash models (minimal / low / high):
+ *     budget_tokens < 4 096   → "minimal"
+ *     budget_tokens < 16 000  → "low"
+ *     budget_tokens >= 16 000 → "high"
+ *
+ *   Non-Flash Gemini 3 models (low / high — "minimal" not supported):
+ *     budget_tokens < 8 192   → "low"
+ *     budget_tokens >= 8 192  → "high"
+ */
+export function budgetTokensToThinkingLevel(budgetTokens, model) {
+    const isFlash = isGemini3Flash(model);
+    if (budgetTokens === undefined) {
+        // No budget provided — default to the lightest enabled level.
+        return isFlash ? 'minimal' : 'low';
+    }
+    if (isFlash) {
+        if (budgetTokens < 4096)
+            return 'minimal';
+        if (budgetTokens < 16000)
+            return 'low';
+        return 'high';
+    }
+    // Non-Flash Gemini 3 — "minimal" is not a valid level.
+    return budgetTokens < 8192 ? 'low' : 'high';
+}
+/**
+ * Map voice to Vertex AI format
+ * Supports:
+ * 1. OpenAI voice names (alloy, echo, fable, etc.) - will be mapped
+ * 2. Vertex AI voice names (en-US-Studio-O, etc.) - used directly
+ * 3. Dict with languageCode and name - used as-is
+ */
+export function mapVoiceToVertexFormat(voice, voiceMappings, defaultLanguageCode = 'en-US') {
+    if (!voice) {
+        return null;
+    }
+    if (typeof voice === 'object' && 'name' in voice && 'languageCode' in voice) {
+        return {
+            languageCode: voice.languageCode,
+            name: voice.name,
+        };
+    }
+    const voiceStr = voice;
+    let mappedVoiceName;
+    if (voiceMappings && voiceStr in voiceMappings) {
+        mappedVoiceName = voiceMappings[voiceStr];
+    }
+    else {
+        mappedVoiceName = voiceStr;
+    }
+    const parts = mappedVoiceName.split('-');
+    let languageCode;
+    if (parts.length >= 2) {
+        languageCode = `${parts[0]}-${parts[1]}`;
+    }
+    else {
+        languageCode = defaultLanguageCode;
+    }
+    return {
+        languageCode,
+        name: mappedVoiceName,
+    };
+}
+//# sourceMappingURL=utils.js.map