ai21_api

const https = require('https');
const http = require('http');
const zlib = require('zlib');

const API_KEY = `твой ключ`;

const options = {
    hostname: 'api.ai21.com',
    port: 443,
    method: 'POST',
    "headers": {
        "authorization": `Bearer ${API_KEY}`,
        "content-type": "application/json",
    },
};

const readBody = (res) => new Promise((resolve, reject) => {
    let buffer = '';

    res.on('data', chunk => {
        buffer += chunk;
    });

    res.on('end', () => {
        try {
            if (res.headers['content-encoding'] === 'gzip') {
                zlib.gunzip(buffer, (err, data) => {
                    if (err) return reject(err);

                    resolve(JSON.parse(data));
                });
            } else {
                resolve(JSON.parse(buffer));
            }
        } catch (e) {
            console.error(buffer);
            reject(e);
        }
    });
});

const JSON_stringify_fixed = (obj) => JSON.stringify(obj).replace(
    /[\u007f-\uffff]/g,
    (c) => '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4),
);

const request = (path, data) =>
    new Promise((resolve, reject) => {
        const textData = JSON_stringify_fixed(data);
        options.headers['Content-Length'] = textData.length;
        const req = https.request({ ...options, path }, async (res) => {
            try {
                const body = await readBody(res);
                console.log(body);
                const error = body.exception || body.error;
                if (error) {
                    reject(error);
                } else {
                    resolve(body);
                }
            } catch (e) {
                reject(e);
            }
        });

        req.write(textData);
        req.end();
    });


function preparePrompt(messages) {
    return (messages.filter(m => m.content?.trim()).map(m => {
        let author = '';
        switch (m.role) {
            case 'system': return m.content.trim();
            case 'user': author = 'User'; break;
            case 'assistant': author = 'Assistant'; break;
            default: author = m.role; break;
        }

        return `${author}: ${m.content.trim()}`;
    }).join('\n\n') + `\n\nAssistant:`);
}

async function generate(data) {
    const prompt = preparePrompt(data.messages);
    const model = "j2-ultra";
    const stopSequences = ["Human:", "You:", "Assistant", "User:", "[System note:", "System note:"];

    const requestData = {
        prompt, promptLength: prompt.length,
        model,
        numResults: 1,
        maxTokens: data.max_tokens,
        stopSequences, numStopSequences: stopSequences.length,
        temperature: data.temperature,
        topKReturn: 0,
        topP: 1,
        "frequencyPenalty": {
            "scale": data.frequency_penalty, "applyToWhitespaces": false,
            "applyToPunctuations": false, "applyToNumbers": false,
            "applyToStopwords": false, "applyToEmojis": false
        },
        "presencePenalty": {
            "scale": data.presence_penalty, "applyToWhitespaces": false,
            "applyToPunctuations": false, "applyToNumbers": false,
            "applyToStopwords": false, "applyToEmojis": false
        },
        "countPenalty": {
            "scale": 0, "applyToWhitespaces": false,
            "applyToPunctuations": false, "applyToNumbers": false,
            "applyToStopwords": false, "applyToEmojis": false
        }
    };
    console.log(requestData);

    const result = await request(`/studio/v1/${model}/complete`, requestData);

    return {
        completion: result.completions[0].data.text,
        completion_tokens: result.completions[0].data.tokens.length,
        prompt_tokens: result.prompt.tokens.length,
    }
}

async function main() {
    const server = http.createServer(async (req, res) => {
        res.setHeader('Content-Type', 'application/json');
        if (req.method.toUpperCase() === 'POST') {
            const body = await readBody(req);
            let result;
            try {
                result = await generate(body);
            } catch (e) {
                result = { completion: e.toString() };
            }

            const id = `chatcmpl-${(Math.random().toString(36).slice(2))}`;
            const created = Math.floor(Date.now() / 1000);

            res.write(JSON.stringify({
                id, created,
                object: 'chat.completion',
                model: 'Elehayym',
                choices: [{
                    message: {
                        role: 'assistant',
                        content: result.completion,
                    },
                    finish_reason: 'stop',
                    index: 0,
                }],
                usage: {
                    prompt_tokens: result.prompt_tokens,
                    completion_tokens: result.completion_tokens,
                    total_tokens: result.prompt_tokens + result.completion_tokens,
                }
            }));
            res.end();
        } else {
            if (req.url === '/' || req.url.startsWith('/?')) {
              res.write(JSON.stringify({
                  proxy_url: `http://127.0.0.1:5004/api`,
              }));
            } else {
              res.write(JSON.stringify({
                  object: 'list',
                  data: [
                      { id: 'gpt-4', object: 'model', created: Date.now(), owned_by: 'openai', permission: [], root: 'gpt-4', parent: null },
                  ],
                url: req.url,
              }));
            }
        }
        res.end();
    });

    server.listen(5004, '0.0.0.0', () => {
        console.log(`api: 'http://127.0.0.1:5004/api`);
    });
}

main().catch(console.error);