@callmedayz/ai-prompt-toolkit/dist/openrouter-completion.js

Professional AI prompt engineering toolkit with advanced template features, real-time dashboards, conditional logic, template inheritance, live monitoring, OpenRouter integration, and 310+ model support

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.OpenRouterCompletion = void 0;
const openrouter_client_1 = require("./openrouter-client");
const openrouter_types_1 = require("./openrouter-types");
/**
 * OpenRouter completion service for generating text responses
 */
class OpenRouterCompletion {
    constructor(client) {
        this.client = client;
    }
    /**
     * Generate a completion for a single prompt
     */
    async complete(prompt, config = {}) {
        if (config.stream) {
            throw new Error('Use completeStream() for streaming completions');
        }
        const messages = [
            { role: 'user', content: prompt }
        ];
        return this.chat(messages, config);
    }
    /**
     * Generate a streaming completion for a single prompt
     */
    async completeStream(prompt, callback, config = {}) {
        const messages = [
            { role: 'user', content: prompt }
        ];
        return this.chatStream(messages, callback, config);
    }
    /**
     * Generate a completion for a chat conversation
     */
    async chat(messages, config = {}) {
        if (config.stream) {
            throw new Error('Use chatStream() for streaming completions');
        }
        const request = {
            model: config.model || openrouter_types_1.DEFAULT_FREE_MODEL,
            messages,
            max_tokens: config.maxTokens,
            temperature: config.temperature,
            top_p: config.topP,
            stop: config.stop,
            stream: false
        };
        const response = await this.client.completion(request);
        if (!response.choices || response.choices.length === 0) {
            throw new Error('No completion choices returned from OpenRouter');
        }
        const choice = response.choices[0];
        return {
            text: choice.message.content,
            model: response.model,
            usage: {
                promptTokens: response.usage.prompt_tokens,
                completionTokens: response.usage.completion_tokens,
                totalTokens: response.usage.total_tokens
            },
            finishReason: choice.finish_reason
        };
    }
    /**
     * Generate a streaming completion for a chat conversation
     */
    async chatStream(messages, callback, config = {}) {
        const request = {
            model: config.model || openrouter_types_1.DEFAULT_FREE_MODEL,
            messages,
            max_tokens: config.maxTokens,
            temperature: config.temperature,
            top_p: config.topP,
            stop: config.stop,
            stream: true
        };
        const stream = await this.client.completionStream(request);
        const reader = stream.getReader();
        try {
            while (true) {
                const { done, value } = await reader.read();
                if (done) {
                    callback({
                        content: '',
                        isComplete: true,
                        model: request.model
                    });
                    break;
                }
                callback({
                    content: value,
                    isComplete: false,
                    model: request.model
                });
            }
        }
        finally {
            reader.releaseLock();
        }
    }
    /**
     * Generate a completion with system message
     */
    async completeWithSystem(systemMessage, userPrompt, config = {}) {
        const messages = [
            { role: 'system', content: systemMessage },
            { role: 'user', content: userPrompt }
        ];
        return this.chat(messages, config);
    }
    /**
     * Collect streaming response into a complete result
     */
    async completeStreamCollected(prompt, config = {}) {
        const chunks = [];
        let fullText = '';
        await this.completeStream(prompt, (chunk) => {
            if (!chunk.isComplete && chunk.content) {
                chunks.push(chunk.content);
                fullText += chunk.content;
            }
        }, config);
        return { text: fullText, chunks };
    }
    /**
     * Test a prompt against a model and return the response
     */
    async testPrompt(prompt, model, options = {}) {
        return this.complete(prompt, {
            model,
            maxTokens: options.maxTokens || 100,
            temperature: options.temperature || 0.7
        });
    }
    /**
     * Validate that a prompt works with a specific model
     */
    async validatePrompt(prompt, model) {
        try {
            const result = await this.testPrompt(prompt, model, { maxTokens: 50 });
            return { isValid: true, result };
        }
        catch (error) {
            return {
                isValid: false,
                error: error instanceof Error ? error.message : 'Unknown error'
            };
        }
    }
    /**
     * Create a completion service from API key
     */
    static fromApiKey(apiKey) {
        const client = new openrouter_client_1.OpenRouterClient({ apiKey });
        return new OpenRouterCompletion(client);
    }
    /**
     * Create a completion service from environment variables
     */
    static fromEnv() {
        const client = openrouter_client_1.OpenRouterClient.fromEnv();
        return new OpenRouterCompletion(client);
    }
}
exports.OpenRouterCompletion = OpenRouterCompletion;
//# sourceMappingURL=openrouter-completion.js.map