@kdump/code-cli-any-llm/dist/transformers/response.transformer.js

> A unified gateway for the Gemini, opencode, crush, and Qwen Code AI CLIs

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResponseTransformer = void 0;
const common_1 = require("@nestjs/common");
const ToolCallProcessor_1 = require("../utils/zhipu/ToolCallProcessor");
let ResponseTransformer = class ResponseTransformer {
    toolCallProcessor = new ToolCallProcessor_1.ToolCallProcessor();
    transformResponse(openAIResponse) {
        const geminiResponse = {
            candidates: [],
        };
        if (openAIResponse.choices && openAIResponse.choices.length > 0) {
            geminiResponse.candidates = openAIResponse.choices.map((choice, index) => this.transformChoice(choice, index));
        }
        if (openAIResponse.usage) {
            geminiResponse.usageMetadata = this.transformUsage(openAIResponse.usage);
        }
        return geminiResponse;
    }
    transformChoice(choice, index) {
        const content = this.transformOpenAIMessageToGeminiContent(choice.message);
        return {
            content,
            index,
            finishReason: this.transformFinishReason(choice.finish_reason),
        };
    }
    transformOpenAIMessageToGeminiContent(message) {
        const parts = [];
        const messageObj = message;
        if (messageObj.reasoning_content) {
            parts.push({
                text: messageObj.reasoning_content,
                thought: true,
            });
        }
        if (messageObj.content) {
            parts.push({ text: messageObj.content });
        }
        if (messageObj.tool_calls && messageObj.tool_calls.length > 0) {
            for (const toolCall of messageObj.tool_calls) {
                const args = this.toolCallProcessor.parseToolCallArguments(toolCall.function.arguments, toolCall.function.name, 'qwen');
                parts.push({
                    functionCall: {
                        id: toolCall.id,
                        name: toolCall.function.name,
                        args: args,
                    },
                });
            }
        }
        const normalizedParts = this.toolCallProcessor.normalizeTextToolCalls(parts);
        parts.splice(0, parts.length, ...normalizedParts);
        if (parts.length === 0 &&
            (messageObj.content ||
                messageObj.reasoning_content ||
                messageObj.tool_calls)) {
            parts.push({ text: '' });
        }
        return {
            role: 'model',
            parts,
        };
    }
    transformFinishReason(reason) {
        const mapping = {
            stop: 'STOP',
            length: 'MAX_TOKENS',
            tool_calls: 'STOP',
            content_filter: 'SAFETY',
        };
        return mapping[reason] || 'OTHER';
    }
    transformUsage(usage) {
        const usageObj = usage;
        return {
            promptTokenCount: usageObj.prompt_tokens || 0,
            candidatesTokenCount: usageObj.completion_tokens || 0,
            totalTokenCount: usageObj.total_tokens || 0,
        };
    }
    transformStreamChunk(chunk) {
        const geminiResponse = {
            candidates: [],
        };
        const chunkObj = chunk;
        if (chunkObj.choices && chunkObj.choices.length > 0) {
            const choice = chunkObj.choices[0];
            const content = {
                role: 'model',
                parts: [],
            };
            if (choice.delta && choice.delta.content) {
                content.parts.push({ text: choice.delta.content });
            }
            if (choice.delta && choice.delta.tool_calls) {
                for (const toolCall of choice.delta.tool_calls) {
                    if (toolCall.function && toolCall.function.name) {
                        content.parts.push({
                            functionCall: {
                                id: toolCall.id,
                                name: toolCall.function.name,
                                args: toolCall.function.arguments
                                    ? JSON.parse(toolCall.function.arguments)
                                    : {},
                            },
                        });
                    }
                }
            }
            const normalizedStreamParts = this.toolCallProcessor.normalizeTextToolCalls(content.parts);
            const targetStreamParts = content.parts;
            targetStreamParts.splice(0, targetStreamParts.length, ...normalizedStreamParts);
            geminiResponse.candidates.push({
                content,
                index: choice.index || 0,
                finishReason: choice.finish_reason
                    ? this.transformFinishReason(choice.finish_reason)
                    : undefined,
            });
        }
        return geminiResponse;
    }
};
exports.ResponseTransformer = ResponseTransformer;
exports.ResponseTransformer = ResponseTransformer = __decorate([
    (0, common_1.Injectable)()
], ResponseTransformer);
//# sourceMappingURL=response.transformer.js.map