n8n/dist/modules/instance-ai/eval/openai-responses-envelope.js

n8n Workflow Automation Tool

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.reverseTranslateOpenAiResponsesRequest = reverseTranslateOpenAiResponsesRequest;
exports.extractResponsesRequestModel = extractResponsesRequestModel;
exports.isResponsesStreamRequested = isResponsesStreamRequested;
exports.forwardTranslateToResponsesEnvelope = forwardTranslateToResponsesEnvelope;
exports.forwardTranslateToResponsesSseEvents = forwardTranslateToResponsesSseEvents;
exports.buildResponsesErrorEnvelope = buildResponsesErrorEnvelope;
const node_crypto_1 = require("node:crypto");
const openai_envelope_1 = require("./openai-envelope");
const OPENAI_RESPONSES_SYNTHETIC_URL = 'https://api.openai.com/v1/responses';
const DEFAULT_MODEL = 'gpt-4o-mini';
function reverseTranslateOpenAiResponsesRequest(body) {
    return {
        url: OPENAI_RESPONSES_SYNTHETIC_URL,
        method: 'POST',
        body: body ?? {},
    };
}
function extractResponsesRequestModel(body) {
    if (typeof body !== 'object' || body === null)
        return DEFAULT_MODEL;
    const model = body.model;
    return typeof model === 'string' && model.length > 0 ? model : DEFAULT_MODEL;
}
function isResponsesStreamRequested(body) {
    if (typeof body !== 'object' || body === null)
        return false;
    return body.stream === true;
}
function forwardTranslateToResponsesEnvelope(mockResponse, model) {
    const toolCalls = (0, openai_envelope_1.extractToolCalls)(mockResponse?.body);
    const responseId = `resp_${(0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 32)}`;
    const now = Math.floor(Date.now() / 1000);
    const output = toolCalls.length > 0
        ? toolCallsToResponsesOutput(toolCalls)
        : [buildAssistantMessage(extractResponsesContent(mockResponse?.body))];
    return {
        id: responseId,
        object: 'response',
        created_at: now,
        status: 'completed',
        model,
        output,
        usage: {
            input_tokens: 0,
            output_tokens: 0,
            total_tokens: 0,
        },
    };
}
function forwardTranslateToResponsesSseEvents(mockResponse, model) {
    const responseId = `resp_${(0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 32)}`;
    const createdAt = Math.floor(Date.now() / 1000);
    const toolCalls = (0, openai_envelope_1.extractToolCalls)(mockResponse?.body);
    const baseResponse = (status, output) => ({
        id: responseId,
        object: 'response',
        created_at: createdAt,
        status,
        model,
        output,
        usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
    });
    const events = [];
    events.push({ event: 'response.created', data: { response: baseResponse('in_progress', []) } });
    events.push({
        event: 'response.in_progress',
        data: { response: baseResponse('in_progress', []) },
    });
    if (toolCalls.length > 0) {
        const finalItems = toolCallsToResponsesOutput(toolCalls);
        toolCalls.forEach((tc, callIndex) => {
            const finalItem = finalItems[callIndex];
            const itemId = finalItem.id;
            const initialItem = { ...finalItem, arguments: '' };
            events.push({
                event: 'response.output_item.added',
                data: { output_index: callIndex, item: initialItem },
            });
            if (tc.arguments.length > 0) {
                events.push({
                    event: 'response.function_call_arguments.delta',
                    data: {
                        item_id: itemId,
                        output_index: callIndex,
                        delta: tc.arguments,
                    },
                });
            }
            events.push({
                event: 'response.function_call_arguments.done',
                data: {
                    item_id: itemId,
                    output_index: callIndex,
                    arguments: tc.arguments,
                },
            });
            events.push({
                event: 'response.output_item.done',
                data: { output_index: callIndex, item: finalItem },
            });
        });
        events.push({
            event: 'response.completed',
            data: { response: baseResponse('completed', finalItems) },
        });
        return events;
    }
    const content = extractResponsesContent(mockResponse?.body);
    const messageId = `msg_${(0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 16)}`;
    const messageItem = {
        id: messageId,
        type: 'message',
        role: 'assistant',
        content: [{ type: 'output_text', text: content, annotations: [] }],
        status: 'completed',
    };
    events.push({
        event: 'response.output_item.added',
        data: {
            output_index: 0,
            item: {
                ...messageItem,
                content: [{ type: 'output_text', text: '', annotations: [] }],
                status: 'in_progress',
            },
        },
    });
    events.push({
        event: 'response.content_part.added',
        data: {
            item_id: messageId,
            output_index: 0,
            content_index: 0,
            part: { type: 'output_text', text: '', annotations: [] },
        },
    });
    if (content.length > 0) {
        events.push({
            event: 'response.output_text.delta',
            data: {
                item_id: messageId,
                output_index: 0,
                content_index: 0,
                delta: content,
            },
        });
    }
    events.push({
        event: 'response.output_text.done',
        data: {
            item_id: messageId,
            output_index: 0,
            content_index: 0,
            text: content,
        },
    });
    events.push({
        event: 'response.content_part.done',
        data: {
            item_id: messageId,
            output_index: 0,
            content_index: 0,
            part: { type: 'output_text', text: content, annotations: [] },
        },
    });
    events.push({
        event: 'response.output_item.done',
        data: { output_index: 0, item: messageItem },
    });
    events.push({
        event: 'response.completed',
        data: { response: baseResponse('completed', [messageItem]) },
    });
    return events;
}
function buildResponsesErrorEnvelope(message) {
    return {
        error: {
            message,
            type: 'eval_wire_server_error',
            code: 'eval_mock_generation_failed',
            param: null,
        },
    };
}
function toolCallsToResponsesOutput(toolCalls) {
    return toolCalls.map((tc) => ({
        id: `fc_${(0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 16)}`,
        type: 'function_call',
        call_id: tc.id,
        name: tc.name,
        arguments: tc.arguments,
    }));
}
function buildAssistantMessage(text) {
    return {
        id: `msg_${(0, node_crypto_1.randomUUID)().replace(/-/g, '').slice(0, 16)}`,
        type: 'message',
        role: 'assistant',
        status: 'completed',
        content: [{ type: 'output_text', text, annotations: [] }],
    };
}
function extractResponsesContent(body) {
    if (body === null || body === undefined)
        return '';
    if (typeof body === 'string')
        return body;
    if (typeof body !== 'object')
        return String(body);
    const obj = body;
    if (typeof obj.output_text === 'string')
        return obj.output_text;
    const output = obj.output;
    if (Array.isArray(output) && output.length > 0) {
        for (const item of output) {
            if (typeof item !== 'object' || item === null)
                continue;
            const content = item.content;
            if (!Array.isArray(content) || content.length === 0)
                continue;
            const first = content[0];
            if (typeof first === 'object' && first !== null) {
                const text = first.text;
                if (typeof text === 'string')
                    return text;
            }
        }
    }
    if (typeof obj.content === 'string')
        return obj.content;
    if (typeof obj.message === 'string')
        return obj.message;
    return JSON.stringify(body);
}
//# sourceMappingURL=openai-responses-envelope.js.map