purai.js/dist/classes/PurAi.js

NPM package for PurAI API

import { ApiRequestPath } from '../types/api.js';
import { ApiStyle } from '../types/purAi.js';
import { generateResponse } from '../utils/generateResponse.js';
import { resolveChatMessages } from '../utils/resolveChatMessages.js';
import { Http } from './Http.js';
import PurAiError from './PurAiError.js';
export class PurAi {
    #key;
    #http;
    options;
    constructor(key, options = {}) {
        this.#key = key;
        this.options = Object.assign({
            baseUrl: 'https://indev.alpha.api.purlabs.xyz/api',
            version: 'v1',
            apiStyle: ApiStyle.Default
        }, options);
        this.#http = new Http(this.#key, `${this.options.baseUrl}/${this.options.version}`);
    }
    ;
    async models() {
        return await this.#http.get(ApiRequestPath.Models);
    }
    ;
    async chat(model, messages, unfiltered = false) {
        switch (this.options.apiStyle) {
            case ApiStyle.Default:
                {
                    const response = await this.#http.post(ApiRequestPath.ChatCompletions, {
                        model,
                        messages: resolveChatMessages(messages)
                    });
                    return generateResponse(response, {
                        message: response.response.messages[response.response.messages.length - 1],
                        history: response.response.messages
                    });
                }
                ;
            case ApiStyle.OpenAi:
                {
                    const response = await this.#http.post(ApiRequestPath.OpenAiChatCompletions, {
                        model,
                        filtered: !unfiltered,
                        messages: resolveChatMessages(messages)
                    });
                    return generateResponse(response, {
                        choices: response.choices.map(choice => ({
                            finishReason: choice.finish_reason,
                            index: choice.index,
                            message: choice.message,
                            ...(choice.logprops ? { logProps: choice.logprops } : {})
                        })),
                        created: response.created,
                        id: response.id,
                        model: response.model,
                        object: response.object,
                        usage: {
                            completionTokens: response.usage.completion_tokens,
                            promptTokens: response.usage.prompt_tokens,
                            totalTokens: response.usage.total_tokens
                        }
                    });
                }
                ;
        }
        ;
    }
    ;
    async generateImage(model, prompt) {
        switch (this.options.apiStyle) {
            case ApiStyle.Default:
                {
                    const response = await this.#http.post(ApiRequestPath.ImageGenerate, {
                        model,
                        prompt
                    });
                    return generateResponse(response, {
                        image: response.response
                    });
                }
                ;
            case ApiStyle.OpenAi:
                {
                    throw new PurAiError('OpenAI style is not supported for image generation yet');
                }
                ;
        }
        ;
    }
    ;
}
;