@undefineds.co/xpod 0.3.58 → 0.3.62

package/dist/api/ai-gateway/providers/ProviderRuntimeAdapter.js

@@ -0,0 +1,645 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiCompatibleRuntimeAdapter = exports.BaseProviderRuntimeAdapter = void 0;
+exports.toResponsesBody = toResponsesBody;
+exports.toAnthropicBody = toAnthropicBody;
+exports.toChatCompletionsBody = toChatCompletionsBody;
+exports.parseOpenAiResponsesSse = parseOpenAiResponsesSse;
+exports.parseAnthropicMessagesSse = parseAnthropicMessagesSse;
+exports.parseCompatibleChatSse = parseCompatibleChatSse;
+exports.parseJsonSseData = parseJsonSseData;
+exports.parseOpenAiUsage = parseOpenAiUsage;
+exports.parseAnthropicUsage = parseAnthropicUsage;
+exports.parseChatUsage = parseChatUsage;
+exports.objectField = objectField;
+exports.stringField = stringField;
+exports.numberField = numberField;
+exports.classifyProviderStatus = classifyProviderStatus;
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const provider_http_transport_1 = require("../../service/provider-http-transport");
+class BaseProviderRuntimeAdapter {
+    constructor(options = {}) {
+        this.transport = options.transport ?? new provider_http_transport_1.ProviderHttpTransport();
+        this.maxOutputTokensDefault = options.maxOutputTokensDefault ?? 4096;
+    }
+    resolveBaseUrl(input) {
+        const candidate = trimTrailingSlash(input.configuredBaseUrl ?? input.defaultBaseUrl);
+        if (!input.safeBaseUrls.map(trimTrailingSlash).includes(candidate)) {
+            throw new errors_1.GatewayProtocolError('Configured provider endpoint is not allowed', {
+                code: 'invalid_request',
+                status: 400,
+                details: {
+                    provider: this.provider,
+                },
+            });
+        }
+        return candidate;
+    }
+    handleTransportError(error, secret) {
+        if (error instanceof errors_1.GatewayProtocolError) {
+            throw error;
+        }
+        const status = typeof error?.status === 'number'
+            ? error.status
+            : 502;
+        const headers = error?.headers;
+        const retryAfter = headers?.get('Retry-After') ?? headers?.get('retry-after') ?? undefined;
+        const body = typeof error?.body === 'string'
+            ? redactSecret(error.body, secret)
+            : undefined;
+        throw new errors_1.GatewayProtocolError(`Provider request failed with status ${status}`, {
+            code: 'provider_error',
+            status,
+            details: {
+                provider: this.provider,
+                providerStatusCode: status,
+                classification: classifyProviderStatus(status),
+                ...(retryAfter ? { retryAfter } : {}),
+                ...(body ? { body } : {}),
+            },
+            cause: error,
+        });
+    }
+}
+exports.BaseProviderRuntimeAdapter = BaseProviderRuntimeAdapter;
+class OpenAiCompatibleRuntimeAdapter extends BaseProviderRuntimeAdapter {
+    constructor(options) {
+        super(options);
+        this.provider = options.provider;
+        this.defaultBaseUrl = options.defaultBaseUrl;
+        this.safeBaseUrls = options.safeBaseUrls;
+        this.supportsImages = options.supportsImages ?? true;
+        this.supportsDeveloperMessages = options.supportsDeveloperMessages ?? true;
+        this.allowToolChoiceRequired = options.allowToolChoiceRequired ?? true;
+        this.descriptor = options.descriptor;
+        this.reasoningEffortMapper = options.reasoningEffortMapper;
+        this.fallbackReasoningBody = options.fallbackReasoningBody;
+        this.preserveReasoningContent = options.preserveReasoningContent ?? false;
+    }
+    async *execute(input) {
+        this.validateRequest(input.request);
+        const baseUrl = this.resolveBaseUrl({
+            configuredBaseUrl: input.credential?.baseUrl,
+            defaultBaseUrl: this.defaultBaseUrl,
+            safeBaseUrls: this.safeBaseUrls,
+        });
+        const model = this.findRegisteredModel(input.request.model);
+        const body = toChatCompletionsBody(input.request, {
+            reasoningEffort: this.resolveReasoningEffort(input.request, model),
+            extraReasoningBody: this.resolveFallbackReasoningBody(input.request, model),
+            preserveReasoningContent: this.preserveReasoningContent,
+        });
+        try {
+            yield* parseCompatibleChatSse(this.transport.postSse({
+                url: `${baseUrl}/chat/completions`,
+                apiKey: input.apiKey,
+                body,
+                proxy: input.credential?.proxy,
+                signal: input.signal,
+            }), input.apiKey);
+        }
+        catch (error) {
+            this.handleTransportError(error, input.apiKey);
+        }
+    }
+    validateRequest(request) {
+        if (!this.supportsImages && request.messages.some((message) => message.content.some((part) => part.type === 'image'))) {
+            throw new errors_1.GatewayProtocolError(`${this.provider} does not support image input through this gateway`, {
+                code: 'invalid_request',
+                status: 400,
+                details: { provider: this.provider, capability: 'imageInput' },
+            });
+        }
+        if (!this.supportsDeveloperMessages && request.messages.some((message) => message.role === 'developer')) {
+            throw new errors_1.GatewayProtocolError(`${this.provider} does not support developer role messages`, {
+                code: 'invalid_request',
+                status: 400,
+                details: { provider: this.provider, capability: 'developerMessages' },
+            });
+        }
+        const chatExtensions = request.protocolExtensions.chatCompletions ?? {};
+        if (!this.allowToolChoiceRequired && chatExtensions.tool_choice === 'required') {
+            throw new errors_1.GatewayProtocolError(`${this.provider} does not support required tool_choice`, {
+                code: 'invalid_request',
+                status: 400,
+                details: { provider: this.provider, capability: 'tool_choice.required' },
+            });
+        }
+    }
+    findRegisteredModel(model) {
+        return this.descriptor?.models.find((candidate) => candidate.id === model);
+    }
+    resolveReasoningEffort(request, model) {
+        const effort = request.reasoning?.effort;
+        if (!effort) {
+            return undefined;
+        }
+        if (this.reasoningEffortMapper) {
+            return this.reasoningEffortMapper(effort, request, model);
+        }
+        return undefined;
+    }
+    resolveFallbackReasoningBody(request, model) {
+        const effort = request.reasoning?.effort;
+        if (!effort || !this.fallbackReasoningBody) {
+            return {};
+        }
+        return this.fallbackReasoningBody(effort, request, model);
+    }
+}
+exports.OpenAiCompatibleRuntimeAdapter = OpenAiCompatibleRuntimeAdapter;
+function toResponsesBody(request) {
+    return {
+        ...request.protocolExtensions.responses,
+        model: request.model,
+        stream: true,
+        ...(request.instructions ? { instructions: request.instructions } : {}),
+        ...(request.previousResponseId ? { previous_response_id: request.previousResponseId } : {}),
+        ...(request.maxOutputTokens !== undefined ? { max_output_tokens: request.maxOutputTokens } : {}),
+        ...(request.reasoning?.effort ? { reasoning: { effort: request.reasoning.effort } } : {}),
+        input: request.messages.map((message) => ({
+            role: message.role,
+            content: message.content.flatMap(toOpenAiContentPart),
+            ...(message.name ? { name: message.name } : {}),
+            ...(message.toolCallId ? { tool_call_id: message.toolCallId } : {}),
+        })),
+        ...(request.tools.length > 0 ? { tools: request.tools.map(toOpenAiTool) } : {}),
+    };
+}
+function toAnthropicBody(request, options = {}) {
+    const maxTokens = request.maxOutputTokens ?? options.maxOutputTokensDefault ?? 4096;
+    return {
+        ...request.protocolExtensions.anthropic,
+        model: request.model,
+        stream: true,
+        max_tokens: maxTokens,
+        ...(request.instructions ? { system: request.instructions } : {}),
+        messages: request.messages.map((message) => ({
+            role: message.role === 'tool' ? 'user' : message.role,
+            content: message.role === 'tool'
+                ? [{ type: 'tool_result', tool_use_id: message.toolCallId, content: contentToText(message.content) }]
+                : message.content.map(toAnthropicContentPart),
+        })),
+        ...(request.tools.length > 0 ? { tools: request.tools.map(toAnthropicTool) } : {}),
+        ...(request.reasoning?.effort
+            ? {
+                thinking: {
+                    type: 'enabled',
+                    budget_tokens: Number.isFinite(Number(request.reasoning.effort))
+                        ? Number(request.reasoning.effort)
+                        : 1024,
+                },
+            }
+            : {}),
+    };
+}
+function toChatCompletionsBody(request, options) {
+    return {
+        ...request.protocolExtensions.chatCompletions,
+        ...options.extraReasoningBody,
+        model: request.model,
+        stream: true,
+        ...(request.maxOutputTokens !== undefined ? { max_tokens: request.maxOutputTokens } : {}),
+        ...(options.reasoningEffort ? { reasoning_effort: options.reasoningEffort } : {}),
+        messages: [
+            ...(request.instructions ? [{ role: 'system', content: request.instructions }] : []),
+            ...request.messages.map((message) => toChatMessage(message, options)),
+        ],
+        ...(request.tools.length > 0 ? { tools: request.tools.map(toChatTool) } : {}),
+    };
+}
+async function* parseOpenAiResponsesSse(events, secret) {
+    const toolArguments = new types_1.ToolArgumentTracker();
+    const itemCallIds = new Map();
+    for await (const event of events) {
+        const payload = parseJsonSseData(event.data);
+        if (!payload) {
+            continue;
+        }
+        const type = stringField(payload, 'type');
+        if (type === 'response.created' || type === 'response.in_progress') {
+            const response = objectField(payload, 'response');
+            const id = stringField(response, 'id');
+            if (id) {
+                toolArguments.reset();
+                itemCallIds.clear();
+                yield { type: 'response.started', id };
+            }
+        }
+        else if (type === 'response.output_text.delta') {
+            const delta = stringField(payload, 'delta');
+            if (delta) {
+                yield { type: 'text.delta', text: delta };
+            }
+        }
+        else if (type === 'response.reasoning_summary_text.delta') {
+            const delta = stringField(payload, 'delta');
+            if (delta) {
+                yield { type: 'reasoning.delta', text: delta };
+            }
+        }
+        else if (type === 'response.output_item.added') {
+            const item = objectField(payload, 'item');
+            if (stringField(item, 'type') === 'function_call') {
+                const callId = stringField(item, 'call_id') ?? stringField(item, 'id');
+                const itemId = stringField(item, 'id');
+                const name = stringField(item, 'name');
+                if (callId && name) {
+                    toolArguments.start(callId);
+                    if (itemId) {
+                        itemCallIds.set(itemId, callId);
+                    }
+                    yield { type: 'tool.started', callId, name };
+                }
+            }
+        }
+        else if (type === 'response.function_call_arguments.delta') {
+            const itemId = stringField(payload, 'item_id');
+            const callId = stringField(payload, 'call_id') ?? (itemId ? itemCallIds.get(itemId) : undefined);
+            const delta = stringField(payload, 'delta');
+            if (callId && delta !== undefined) {
+                toolArguments.append(callId, delta);
+                yield { type: 'tool.arguments.delta', callId, delta };
+            }
+        }
+        else if (type === 'response.output_item.done') {
+            const item = objectField(payload, 'item');
+            if (stringField(item, 'type') === 'function_call') {
+                const callId = stringField(payload, 'call_id') ?? stringField(item, 'call_id') ?? stringField(item, 'id');
+                if (callId) {
+                    toolArguments.complete(callId);
+                    const itemId = stringField(item, 'id');
+                    if (itemId) {
+                        itemCallIds.delete(itemId);
+                    }
+                    yield { type: 'tool.completed', callId };
+                }
+            }
+            else {
+                const callId = stringField(payload, 'call_id');
+                if (!callId) {
+                    continue;
+                }
+                toolArguments.complete(callId);
+                yield { type: 'tool.completed', callId };
+            }
+        }
+        else if (type === 'response.completed') {
+            const response = objectField(payload, 'response');
+            const usage = parseOpenAiUsage(objectField(response, 'usage'));
+            if (usage) {
+                yield { type: 'usage', usage };
+            }
+            yield { type: 'response.completed', finishReason: stringField(response, 'finish_reason') ?? stringField(response, 'status') ?? 'stop' };
+        }
+        else if (type === 'error') {
+            throw providerStreamError(payload, 502, secret);
+        }
+    }
+}
+async function* parseAnthropicMessagesSse(events, secret) {
+    const toolArguments = new types_1.ToolArgumentTracker();
+    const toolBlocks = new Map();
+    let latestStopReason;
+    for await (const event of events) {
+        const payload = parseJsonSseData(event.data);
+        if (!payload) {
+            continue;
+        }
+        const type = stringField(payload, 'type');
+        if (type === 'message_start') {
+            const message = objectField(payload, 'message');
+            const id = stringField(message, 'id');
+            if (id) {
+                toolArguments.reset();
+                toolBlocks.clear();
+                yield { type: 'response.started', id };
+            }
+        }
+        else if (type === 'content_block_start') {
+            const index = numberField(payload, 'index');
+            const contentBlock = objectField(payload, 'content_block');
+            if (index !== undefined && stringField(contentBlock, 'type') === 'tool_use') {
+                const callId = stringField(contentBlock, 'id');
+                const name = stringField(contentBlock, 'name');
+                if (callId && name) {
+                    toolBlocks.set(index, callId);
+                    toolArguments.start(callId);
+                    yield { type: 'tool.started', callId, name };
+                }
+            }
+        }
+        else if (type === 'content_block_delta') {
+            const index = numberField(payload, 'index');
+            const delta = objectField(payload, 'delta');
+            const deltaType = stringField(delta, 'type');
+            if (deltaType === 'text_delta') {
+                const text = stringField(delta, 'text');
+                if (text) {
+                    yield { type: 'text.delta', text };
+                }
+            }
+            else if (deltaType === 'thinking_delta') {
+                const text = stringField(delta, 'thinking');
+                if (text) {
+                    yield { type: 'reasoning.delta', text };
+                }
+            }
+            else if (deltaType === 'signature_delta') {
+                const signature = stringField(delta, 'signature');
+                if (signature) {
+                    yield { type: 'reasoning.signature', provider: 'anthropic', signature };
+                }
+            }
+            else if (deltaType === 'input_json_delta' && index !== undefined) {
+                const callId = toolBlocks.get(index);
+                const partialJson = stringField(delta, 'partial_json');
+                if (callId && partialJson !== undefined) {
+                    toolArguments.append(callId, partialJson);
+                    yield { type: 'tool.arguments.delta', callId, delta: partialJson };
+                }
+            }
+        }
+        else if (type === 'content_block_stop') {
+            const index = numberField(payload, 'index');
+            const callId = index === undefined ? undefined : toolBlocks.get(index);
+            if (callId) {
+                toolArguments.complete(callId);
+                toolBlocks.delete(index);
+                yield { type: 'tool.completed', callId };
+            }
+        }
+        else if (type === 'message_delta') {
+            const delta = objectField(payload, 'delta');
+            latestStopReason = stringField(delta, 'stop_reason') ?? latestStopReason;
+            const usage = parseAnthropicUsage(objectField(payload, 'usage'));
+            if (usage) {
+                yield { type: 'usage', usage };
+            }
+        }
+        else if (type === 'message_stop') {
+            yield { type: 'response.completed', finishReason: stringField(payload, 'stop_reason') ?? latestStopReason ?? 'stop' };
+        }
+        else if (type === 'error') {
+            throw providerStreamError(payload, anthopicErrorStatus(payload), secret);
+        }
+    }
+}
+async function* parseCompatibleChatSse(events, secret) {
+    const toolArguments = new types_1.ToolArgumentTracker();
+    const callIdsByIndex = new Map();
+    const openCallIds = new Set();
+    for await (const event of events) {
+        const payload = parseJsonSseData(event.data);
+        if (!payload) {
+            continue;
+        }
+        if (payload.error) {
+            throw providerStreamError(payload, 502, secret);
+        }
+        const id = stringField(payload, 'id');
+        const choices = Array.isArray(payload.choices) ? payload.choices : [];
+        if (id && choices.some((choice) => objectField(choice, 'delta').role === 'assistant')) {
+            toolArguments.reset();
+            callIdsByIndex.clear();
+            openCallIds.clear();
+            yield { type: 'response.started', id };
+        }
+        for (const choice of choices) {
+            const delta = objectField(choice, 'delta');
+            const reasoning = stringField(delta, 'reasoning_content');
+            if (reasoning) {
+                yield { type: 'reasoning.delta', text: reasoning };
+            }
+            const content = stringField(delta, 'content');
+            if (content) {
+                yield { type: 'text.delta', text: content };
+            }
+            const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+            for (const toolCall of toolCalls) {
+                const index = numberField(toolCall, 'index') ?? 0;
+                const fn = objectField(toolCall, 'function');
+                const existingCallId = callIdsByIndex.get(index);
+                const callId = stringField(toolCall, 'id') ?? existingCallId;
+                const name = stringField(fn, 'name');
+                if (callId && !existingCallId && name) {
+                    callIdsByIndex.set(index, callId);
+                    openCallIds.add(callId);
+                    toolArguments.start(callId);
+                    yield { type: 'tool.started', callId, name };
+                }
+                const targetCallId = callId ?? existingCallId;
+                const args = stringField(fn, 'arguments');
+                if (targetCallId && args !== undefined) {
+                    toolArguments.append(targetCallId, args);
+                    yield { type: 'tool.arguments.delta', callId: targetCallId, delta: args };
+                }
+            }
+            const finishReason = stringField(choice, 'finish_reason');
+            if (finishReason) {
+                for (const callId of Array.from(openCallIds)) {
+                    toolArguments.complete(callId);
+                    openCallIds.delete(callId);
+                    yield { type: 'tool.completed', callId };
+                }
+            }
+        }
+        const usage = parseChatUsage(objectField(payload, 'usage'));
+        if (usage) {
+            yield { type: 'usage', usage };
+        }
+        const finishReason = choices.map((choice) => stringField(choice, 'finish_reason')).find((item) => item !== undefined);
+        if (finishReason) {
+            yield { type: 'response.completed', finishReason };
+        }
+    }
+}
+function parseJsonSseData(data) {
+    if (data === '[DONE]') {
+        return undefined;
+    }
+    const parsed = JSON.parse(data);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseOpenAiUsage(usage) {
+    return compactUsage({
+        inputTokens: numberField(usage, 'input_tokens') ?? numberField(usage, 'prompt_tokens'),
+        outputTokens: numberField(usage, 'output_tokens') ?? numberField(usage, 'completion_tokens'),
+        totalTokens: numberField(usage, 'total_tokens'),
+        cacheReadTokens: numberField(objectField(usage, 'input_tokens_details'), 'cached_tokens')
+            ?? numberField(objectField(usage, 'prompt_tokens_details'), 'cached_tokens'),
+        cacheWriteTokens: numberField(objectField(usage, 'input_tokens_details'), 'cache_write_tokens')
+            ?? numberField(objectField(usage, 'prompt_tokens_details'), 'cache_write_tokens'),
+    });
+}
+function parseAnthropicUsage(usage) {
+    return compactUsage({
+        inputTokens: numberField(usage, 'input_tokens'),
+        outputTokens: numberField(usage, 'output_tokens'),
+        cacheReadTokens: numberField(usage, 'cache_read_input_tokens'),
+        cacheWriteTokens: numberField(usage, 'cache_creation_input_tokens'),
+    });
+}
+function parseChatUsage(usage) {
+    return compactUsage({
+        inputTokens: numberField(usage, 'prompt_tokens'),
+        outputTokens: numberField(usage, 'completion_tokens'),
+        totalTokens: numberField(usage, 'total_tokens'),
+        cacheReadTokens: numberField(objectField(usage, 'prompt_tokens_details'), 'cached_tokens'),
+        cacheWriteTokens: numberField(objectField(usage, 'prompt_tokens_details'), 'cache_write_tokens'),
+    });
+}
+function objectField(record, key) {
+    const value = record[key];
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberField(record, key) {
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function classifyProviderStatus(status) {
+    if (status === 401) {
+        return 'authentication';
+    }
+    if (status === 402) {
+        return 'quota_exhausted';
+    }
+    if (status === 403) {
+        return 'authorization';
+    }
+    if (status === 429) {
+        return 'rate_limited';
+    }
+    if (status >= 500) {
+        return 'upstream_unavailable';
+    }
+    return 'provider_error';
+}
+function toOpenAiContentPart(part) {
+    if (part.type === 'text') {
+        return [{ type: 'input_text', text: part.text }];
+    }
+    return [{
+            type: 'input_image',
+            ...(part.imageUrl ? { image_url: part.imageUrl } : {}),
+            ...(part.detail ? { detail: part.detail } : {}),
+        }];
+}
+function toAnthropicContentPart(part) {
+    if (part.type === 'text') {
+        return { type: 'text', text: part.text };
+    }
+    if (part.data) {
+        return {
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: part.mediaType ?? 'image/png',
+                data: part.data,
+            },
+        };
+    }
+    return {
+        type: 'image',
+        source: {
+            type: 'url',
+            url: part.imageUrl,
+        },
+    };
+}
+function toChatMessage(message, options) {
+    const base = {
+        role: message.role,
+        content: message.role === 'tool' ? contentToText(message.content) : chatContent(message.content),
+        ...(message.toolCallId ? { tool_call_id: message.toolCallId } : {}),
+        ...(message.name ? { name: message.name } : {}),
+    };
+    const reasoningContent = message.protocolExtensions?.reasoning_content;
+    if (options.preserveReasoningContent && message.role === 'assistant' && typeof reasoningContent === 'string') {
+        base.reasoning_content = reasoningContent;
+    }
+    return base;
+}
+function chatContent(content) {
+    if (content.every((part) => part.type === 'text')) {
+        return contentToText(content);
+    }
+    return content.map((part) => part.type === 'text'
+        ? { type: 'text', text: part.text }
+        : {
+            type: 'image_url',
+            image_url: {
+                url: part.imageUrl ?? (part.data ? `data:${part.mediaType ?? 'image/png'};base64,${part.data}` : undefined),
+                ...(part.detail ? { detail: part.detail } : {}),
+            },
+        });
+}
+function contentToText(content) {
+    return content
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join('\n');
+}
+function toOpenAiTool(tool) {
+    return {
+        type: 'function',
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        parameters: tool.inputSchema ?? { type: 'object' },
+    };
+}
+function toAnthropicTool(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        input_schema: tool.inputSchema ?? { type: 'object' },
+    };
+}
+function toChatTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            ...(tool.description ? { description: tool.description } : {}),
+            parameters: tool.inputSchema ?? { type: 'object' },
+        },
+    };
+}
+function providerStreamError(payload, status, secret) {
+    const error = objectField(payload, 'error');
+    const rawMessage = stringField(error, 'message') ?? stringField(payload, 'message') ?? 'Provider stream error';
+    const message = secret ? redactSecret(rawMessage, secret) : rawMessage;
+    return new errors_1.GatewayProtocolError(message, {
+        code: 'provider_error',
+        status,
+        details: {
+            providerStatusCode: status,
+            classification: classifyProviderStatus(status),
+            providerErrorType: stringField(error, 'type') ?? stringField(payload, 'type'),
+        },
+    });
+}
+function anthopicErrorStatus(payload) {
+    const error = objectField(payload, 'error');
+    const type = stringField(error, 'type');
+    return type === 'overloaded_error' ? 503 : 502;
+}
+function compactUsage(usage) {
+    const compact = Object.fromEntries(Object.entries(usage).filter(([, value]) => value !== undefined));
+    return Object.keys(compact).length > 0 ? compact : undefined;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/u, '');
+}
+function redactSecret(value, secret) {
+    return secret ? value.split(secret).join('[REDACTED]') : value;
+}
+//# sourceMappingURL=ProviderRuntimeAdapter.js.map