@n8n/n8n-nodes-langchain/dist/nodes/llms/LmChatCohere/cohereV2Client.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createCohereV2ChatClient = createCohereV2ChatClient;
const cohere_ai_1 = require("cohere-ai");
function parseArguments(args) {
    if (!args)
        return {};
    try {
        return JSON.parse(args);
    }
    catch {
        return {};
    }
}
function toV2Messages(request) {
    const messages = [];
    if (request.preamble)
        messages.push({ role: 'system', content: request.preamble });
    for (const item of request.chatHistory ?? []) {
        const content = item.message ?? '';
        switch (item.role) {
            case 'SYSTEM':
                messages.push({ role: 'system', content });
                break;
            case 'USER':
                messages.push({ role: 'user', content });
                break;
            case 'CHATBOT':
                messages.push({
                    role: 'assistant',
                    content,
                    toolCalls: item.toolCalls?.map((toolCall) => ({
                        type: 'function',
                        function: { name: toolCall.name, arguments: JSON.stringify(toolCall.parameters) },
                    })),
                });
                break;
            case 'TOOL':
                break;
        }
    }
    if (request.message)
        messages.push({ role: 'user', content: request.message });
    return messages;
}
function toV2Tools(tools) {
    if (!tools?.length)
        return undefined;
    return tools.map((tool) => {
        const definitions = tool.parameterDefinitions ?? {};
        const properties = {};
        const required = [];
        for (const [name, definition] of Object.entries(definitions)) {
            properties[name] = { type: definition.type, description: definition.description };
            if (definition.required)
                required.push(name);
        }
        return {
            type: 'function',
            function: {
                name: tool.name,
                description: tool.description,
                parameters: { type: 'object', properties, required },
            },
        };
    });
}
function toV2Request(request) {
    return {
        model: request.model ?? '',
        messages: toV2Messages(request),
        temperature: request.temperature,
        maxTokens: request.maxTokens,
        stopSequences: request.stopSequences,
        tools: toV2Tools(request.tools),
    };
}
function extractText(message) {
    return (message?.content ?? []).map((item) => item.text ?? '').join('');
}
function extractToolCalls(message) {
    const toolCalls = (message?.toolCalls ?? [])
        .filter((toolCall) => toolCall.function?.name)
        .map((toolCall) => ({
        name: toolCall.function?.name ?? '',
        parameters: parseArguments(toolCall.function?.arguments),
    }));
    return toolCalls.length ? toolCalls : undefined;
}
function fromV2Response(response) {
    const toolCalls = extractToolCalls(response.message);
    return {
        text: extractText(response.message),
        ...(toolCalls ? { toolCalls } : {}),
        meta: {
            tokens: {
                inputTokens: response.usage?.tokens?.inputTokens,
                outputTokens: response.usage?.tokens?.outputTokens,
            },
        },
        finishReason: response.finishReason,
    };
}
async function* translateStream(stream) {
    const toolNames = [];
    const toolArgs = [];
    let finishReason;
    let usage;
    for await (const event of stream) {
        switch (event.type) {
            case 'content-delta': {
                const text = event.delta?.message?.content?.text;
                if (text)
                    yield { eventType: 'text-generation', text };
                break;
            }
            case 'tool-call-start': {
                const index = event.index ?? toolNames.length;
                toolNames[index] = event.delta?.toolCall?.function?.name ?? '';
                toolArgs[index] = event.delta?.toolCall?.function?.arguments ?? '';
                break;
            }
            case 'tool-call-delta': {
                const index = event.index ?? 0;
                toolArgs[index] =
                    (toolArgs[index] ?? '') + (event.delta?.toolCall?.function?.arguments ?? '');
                break;
            }
            case 'message-end': {
                finishReason = event.delta?.finishReason;
                usage = event.delta?.usage;
                break;
            }
            default:
                break;
        }
    }
    const toolCalls = [];
    for (let index = 0; index < toolNames.length; index++) {
        if (toolNames[index]) {
            toolCalls.push({ name: toolNames[index], parameters: parseArguments(toolArgs[index]) });
        }
    }
    yield {
        eventType: 'stream-end',
        response: {
            text: '',
            toolCalls: toolCalls.length ? toolCalls : undefined,
            meta: {
                tokens: {
                    inputTokens: usage?.tokens?.inputTokens,
                    outputTokens: usage?.tokens?.outputTokens,
                },
            },
            finishReason,
        },
    };
}
function createCohereV2ChatClient(options) {
    const v2Client = new cohere_ai_1.CohereClientV2({ token: options.apiKey });
    const chatClient = {
        chat: async (request) => fromV2Response(await v2Client.chat(toV2Request(request))),
        chatStream: async (request) => translateStream(await v2Client.chatStream(toV2Request(request))),
    };
    return chatClient;
}
//# sourceMappingURL=cohereV2Client.js.map