@prompd/cli 0.4.9 → 0.4.11

package/dist/lib/providers/base.js

@@ -0,0 +1,741 @@
+"use strict";
+/**
+ * Base Provider Classes
+ *
+ * Abstract base class and concrete provider implementations for all supported LLM APIs.
+ * Uses axios for HTTP transport (Node.js environment).
+ * The frontend mirrors this structure but uses electronFetch for CORS bypass.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereProvider = exports.GoogleGeminiProvider = exports.AnthropicProvider = exports.OpenAICompatibleProvider = exports.BaseProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Abstract base class for LLM providers
+ */
+class BaseProvider {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * List available models from config
+     */
+    listModels() {
+        return this.config.models || [];
+    }
+    /**
+     * Helper to create a standard error result
+     */
+    createErrorResult(error, duration) {
+        return {
+            success: false,
+            error,
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            duration
+        };
+    }
+    /**
+     * Helper to create a success result
+     */
+    createSuccessResult(response, usage, duration) {
+        return {
+            success: true,
+            response,
+            usage,
+            duration
+        };
+    }
+    /**
+     * Extract error message from an axios error response
+     */
+    extractAxiosError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const axErr = error;
+            const data = axErr.response?.data;
+            if (data && typeof data === 'object') {
+                const errObj = data.error;
+                if (errObj && typeof errObj.message === 'string') {
+                    return errObj.message;
+                }
+                if (typeof data.message === 'string') {
+                    return data.message;
+                }
+            }
+            return axErr.message;
+        }
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return 'Unknown error';
+    }
+}
+exports.BaseProvider = BaseProvider;
+/**
+ * OpenAI-compatible provider base class
+ *
+ * Many providers (Groq, Mistral, Together, Perplexity, DeepSeek, Ollama)
+ * use the OpenAI chat completions API format. This class handles all of them.
+ */
+class OpenAICompatibleProvider extends BaseProvider {
+    constructor(config, baseUrlOverride) {
+        super(config);
+        this.name = config.name;
+        this.displayName = config.displayName;
+        this.baseUrl = baseUrlOverride || config.baseUrl;
+    }
+    async execute(request) {
+        const startTime = Date.now();
+        try {
+            // Use the Responses API for image generation (OpenAI only, not other compatible providers)
+            if (request.enableImageGeneration && this.name === 'openai') {
+                return await this.executeWithResponses(request, startTime);
+            }
+            const messages = [];
+            // For JSON mode, ensure "json" appears in the system prompt (OpenAI requirement)
+            const systemPrompt = request.mode === 'json'
+                ? (request.systemPrompt ? `${request.systemPrompt}\n\nRespond with valid JSON.` : 'Respond with valid JSON.')
+                : request.systemPrompt;
+            if (systemPrompt) {
+                messages.push({ role: 'system', content: systemPrompt });
+            }
+            messages.push({ role: 'user', content: request.prompt });
+            const body = {
+                model: request.model,
+                messages,
+                stream: false
+            };
+            if (request.maxTokens) {
+                body.max_tokens = request.maxTokens;
+            }
+            if (request.temperature !== undefined) {
+                body.temperature = request.temperature;
+            }
+            // JSON mode - request structured JSON output
+            if (request.mode === 'json') {
+                body.response_format = { type: 'json_object' };
+            }
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+            if (request.apiKey) {
+                headers['Authorization'] = `Bearer ${request.apiKey}`;
+            }
+            const response = await (0, axios_1.default)({
+                method: 'POST',
+                url: `${this.baseUrl}/chat/completions`,
+                headers,
+                data: body,
+                timeout: 120000
+            });
+            const data = response.data;
+            const duration = Date.now() - startTime;
+            // Handle both string responses and multimodal content arrays
+            // Models like GPT-4o can return image content blocks alongside text
+            let content = '';
+            const messageContent = data.choices?.[0]?.message?.content;
+            if (typeof messageContent === 'string') {
+                content = messageContent;
+            }
+            else if (Array.isArray(messageContent)) {
+                for (const block of messageContent) {
+                    if (block.type === 'text') {
+                        content += block.text || '';
+                    }
+                    else if (block.type === 'image_url' && block.image_url?.url) {
+                        content += `\n\n![generated image](${block.image_url.url})\n\n`;
+                    }
+                }
+            }
+            const usage = {
+                promptTokens: data.usage?.prompt_tokens || 0,
+                completionTokens: data.usage?.completion_tokens || 0,
+                totalTokens: data.usage?.total_tokens || 0
+            };
+            return this.createSuccessResult(content, usage, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return this.createErrorResult(this.extractAxiosError(error), duration);
+        }
+    }
+    async *stream(request) {
+        const messages = [];
+        // For JSON mode, ensure "json" appears in the system prompt (OpenAI requirement)
+        const systemPrompt = request.mode === 'json'
+            ? (request.systemPrompt ? `${request.systemPrompt}\n\nRespond with valid JSON.` : 'Respond with valid JSON.')
+            : request.systemPrompt;
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: request.prompt });
+        const body = {
+            model: request.model,
+            messages,
+            stream: true
+        };
+        if (request.maxTokens) {
+            body.max_tokens = request.maxTokens;
+        }
+        if (request.temperature !== undefined) {
+            body.temperature = request.temperature;
+        }
+        // JSON mode - request structured JSON output
+        if (request.mode === 'json') {
+            body.response_format = { type: 'json_object' };
+        }
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (request.apiKey) {
+            headers['Authorization'] = `Bearer ${request.apiKey}`;
+        }
+        const response = await (0, axios_1.default)({
+            method: 'POST',
+            url: `${this.baseUrl}/chat/completions`,
+            headers,
+            data: body,
+            timeout: 120000,
+            responseType: 'stream'
+        });
+        const nodeStream = response.data;
+        let buffer = '';
+        let totalUsage;
+        for await (const chunk of nodeStream) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed === 'data: [DONE]')
+                    continue;
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                try {
+                    const json = JSON.parse(trimmed.slice(6));
+                    const delta = json.choices?.[0]?.delta?.content || '';
+                    // Capture usage if present (some providers send on last chunk)
+                    if (json.usage) {
+                        totalUsage = {
+                            promptTokens: json.usage.prompt_tokens || 0,
+                            completionTokens: json.usage.completion_tokens || 0,
+                            totalTokens: json.usage.total_tokens || 0
+                        };
+                    }
+                    if (delta) {
+                        yield { content: delta, done: false };
+                    }
+                }
+                catch {
+                    // Skip invalid JSON lines
+                }
+            }
+        }
+        yield { content: '', done: true, usage: totalUsage };
+    }
+    /**
+     * Execute using OpenAI's Responses API for image generation
+     * Uses POST /v1/responses with tools: [{"type": "image_generation"}]
+     */
+    async executeWithResponses(request, startTime) {
+        const input = [];
+        if (request.systemPrompt) {
+            input.push({ role: 'developer', content: request.systemPrompt });
+        }
+        input.push({ role: 'user', content: request.prompt });
+        const body = {
+            model: request.model,
+            input,
+            tools: [{ type: 'image_generation' }]
+        };
+        if (request.maxTokens) {
+            body.max_output_tokens = request.maxTokens;
+        }
+        if (request.temperature !== undefined) {
+            body.temperature = request.temperature;
+        }
+        try {
+            const response = await (0, axios_1.default)({
+                method: 'POST',
+                url: `${this.baseUrl}/responses`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${request.apiKey}`
+                },
+                data: body,
+                timeout: 120000
+            });
+            const data = response.data;
+            const duration = Date.now() - startTime;
+            // Parse the Responses API output format
+            // Output is an array of items: message (text), image_generation_call (images)
+            let content = '';
+            const outputItems = data.output || [];
+            for (const item of outputItems) {
+                if (item.type === 'message') {
+                    const parts = item.content || [];
+                    for (const part of parts) {
+                        if (part.type === 'output_text') {
+                            content += part.text || '';
+                        }
+                    }
+                }
+                else if (item.type === 'image_generation_call' && item.result) {
+                    content += `\n\n![generated image](data:image/png;base64,${item.result})\n\n`;
+                }
+            }
+            const usage = {
+                promptTokens: data.usage?.input_tokens || 0,
+                completionTokens: data.usage?.output_tokens || 0,
+                totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+            };
+            return this.createSuccessResult(content, usage, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return this.createErrorResult(this.extractAxiosError(error), duration);
+        }
+    }
+}
+exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
+/**
+ * Anthropic provider using the Messages API
+ */
+class AnthropicProvider extends BaseProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'anthropic';
+        this.displayName = 'Anthropic';
+        this.baseUrl = 'https://api.anthropic.com';
+    }
+    async execute(request) {
+        const startTime = Date.now();
+        try {
+            const messages = [
+                { role: 'user', content: request.prompt }
+            ];
+            // For thinking mode, ensure minimum 1024 tokens for both max_tokens and budget
+            const isThinking = request.mode === 'thinking';
+            const maxTokens = isThinking
+                ? Math.max(1024, request.maxTokens || 4096)
+                : (request.maxTokens || 4096);
+            const body = {
+                model: request.model,
+                max_tokens: maxTokens,
+                messages
+            };
+            if (request.systemPrompt) {
+                body.system = request.systemPrompt;
+            }
+            if (request.temperature !== undefined) {
+                body.temperature = request.temperature;
+            }
+            // Extended thinking mode - uses budget_tokens (minimum 1024)
+            if (isThinking) {
+                body.thinking = { type: 'enabled', budget_tokens: maxTokens };
+            }
+            const response = await (0, axios_1.default)({
+                method: 'POST',
+                url: `${this.baseUrl}/v1/messages`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': request.apiKey,
+                    'anthropic-version': '2023-06-01'
+                },
+                data: body,
+                timeout: 120000
+            });
+            const data = response.data;
+            const duration = Date.now() - startTime;
+            // Anthropic returns content as an array of blocks
+            // With thinking mode, there may be thinking blocks followed by text blocks
+            let content = '';
+            if (data.content && Array.isArray(data.content)) {
+                for (const block of data.content) {
+                    if (block.type === 'text') {
+                        content += block.text || '';
+                    }
+                    else if (block.type === 'thinking') {
+                        content += block.thinking || '';
+                    }
+                    else if (block.type === 'image' && block.source?.data) {
+                        const mimeType = block.source.media_type || 'image/png';
+                        content += `\n\n![generated image](data:${mimeType};base64,${block.source.data})\n\n`;
+                    }
+                }
+            }
+            const usage = {
+                promptTokens: data.usage?.input_tokens || 0,
+                completionTokens: data.usage?.output_tokens || 0,
+                totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+            };
+            return this.createSuccessResult(content, usage, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return this.createErrorResult(this.extractAxiosError(error), duration);
+        }
+    }
+    async *stream(request) {
+        const messages = [
+            { role: 'user', content: request.prompt }
+        ];
+        // For thinking mode, ensure minimum 1024 tokens for both max_tokens and budget
+        const isThinking = request.mode === 'thinking';
+        const maxTokens = isThinking
+            ? Math.max(1024, request.maxTokens || 4096)
+            : (request.maxTokens || 4096);
+        const body = {
+            model: request.model,
+            max_tokens: maxTokens,
+            messages,
+            stream: true
+        };
+        if (request.systemPrompt) {
+            body.system = request.systemPrompt;
+        }
+        if (request.temperature !== undefined) {
+            body.temperature = request.temperature;
+        }
+        // Extended thinking mode - uses budget_tokens (minimum 1024)
+        if (isThinking) {
+            body.thinking = { type: 'enabled', budget_tokens: maxTokens };
+        }
+        const response = await (0, axios_1.default)({
+            method: 'POST',
+            url: `${this.baseUrl}/v1/messages`,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': request.apiKey,
+                'anthropic-version': '2023-06-01'
+            },
+            data: body,
+            timeout: 120000,
+            responseType: 'stream'
+        });
+        const nodeStream = response.data;
+        let buffer = '';
+        let totalUsage;
+        for await (const chunk of nodeStream) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                try {
+                    const json = JSON.parse(trimmed.slice(6));
+                    if (json.type === 'message_start' && json.message?.usage) {
+                        // Capture input tokens from message_start (comes first)
+                        totalUsage = {
+                            promptTokens: json.message.usage.input_tokens || 0,
+                            completionTokens: 0,
+                            totalTokens: json.message.usage.input_tokens || 0
+                        };
+                    }
+                    else if (json.type === 'content_block_delta') {
+                        // Handle both regular text and thinking text deltas
+                        const delta = json.delta?.text || json.delta?.thinking || '';
+                        if (delta) {
+                            yield { content: delta, done: false };
+                        }
+                    }
+                    else if (json.type === 'message_delta' && json.usage) {
+                        // Update with output tokens (comes at end)
+                        const outputTokens = json.usage.output_tokens || 0;
+                        if (totalUsage) {
+                            totalUsage.completionTokens = outputTokens;
+                            totalUsage.totalTokens = totalUsage.promptTokens + outputTokens;
+                        }
+                        else {
+                            totalUsage = {
+                                promptTokens: 0,
+                                completionTokens: outputTokens,
+                                totalTokens: outputTokens
+                            };
+                        }
+                    }
+                }
+                catch {
+                    // Skip invalid JSON
+                }
+            }
+        }
+        yield { content: '', done: true, usage: totalUsage };
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+/**
+ * Google Gemini provider using the Generative Language API
+ */
+class GoogleGeminiProvider extends BaseProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'google';
+        this.displayName = 'Google Gemini';
+        this.baseUrl = 'https://generativelanguage.googleapis.com';
+    }
+    async execute(request) {
+        const startTime = Date.now();
+        try {
+            const contents = [
+                {
+                    parts: [{ text: request.prompt }]
+                }
+            ];
+            const body = {
+                contents
+            };
+            if (request.systemPrompt) {
+                body.systemInstruction = { parts: [{ text: request.systemPrompt }] };
+            }
+            const generationConfig = {};
+            if (request.maxTokens) {
+                generationConfig.maxOutputTokens = request.maxTokens;
+            }
+            if (request.temperature !== undefined) {
+                generationConfig.temperature = request.temperature;
+            }
+            // Enable image output modality for models that support it
+            if (request.enableImageGeneration) {
+                generationConfig.responseModalities = ['TEXT', 'IMAGE'];
+            }
+            if (Object.keys(generationConfig).length > 0) {
+                body.generationConfig = generationConfig;
+            }
+            const url = `${this.baseUrl}/v1beta/models/${request.model}:generateContent?key=${request.apiKey}`;
+            const response = await (0, axios_1.default)({
+                method: 'POST',
+                url,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                data: body,
+                timeout: 120000
+            });
+            const data = response.data;
+            const duration = Date.now() - startTime;
+            // Extract text and images from candidates
+            let content = '';
+            const parts = data.candidates?.[0]?.content?.parts || [];
+            for (const part of parts) {
+                if (part.text) {
+                    content += part.text;
+                }
+                else if (part.inline_data?.data) {
+                    const mimeType = part.inline_data.mime_type || 'image/png';
+                    content += `\n\n![generated image](data:${mimeType};base64,${part.inline_data.data})\n\n`;
+                }
+            }
+            const usageMetadata = data.usageMetadata || {};
+            const usage = {
+                promptTokens: usageMetadata.promptTokenCount || 0,
+                completionTokens: usageMetadata.candidatesTokenCount || 0,
+                totalTokens: usageMetadata.totalTokenCount || 0
+            };
+            return this.createSuccessResult(content, usage, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return this.createErrorResult(this.extractAxiosError(error), duration);
+        }
+    }
+    async *stream(request) {
+        const contents = [
+            {
+                parts: [{ text: request.prompt }]
+            }
+        ];
+        const body = {
+            contents
+        };
+        if (request.systemPrompt) {
+            body.systemInstruction = { parts: [{ text: request.systemPrompt }] };
+        }
+        const generationConfig = {};
+        if (request.maxTokens) {
+            generationConfig.maxOutputTokens = request.maxTokens;
+        }
+        if (request.temperature !== undefined) {
+            generationConfig.temperature = request.temperature;
+        }
+        if (request.enableImageGeneration) {
+            generationConfig.responseModalities = ['TEXT', 'IMAGE'];
+        }
+        if (Object.keys(generationConfig).length > 0) {
+            body.generationConfig = generationConfig;
+        }
+        const url = `${this.baseUrl}/v1beta/models/${request.model}:streamGenerateContent?alt=sse&key=${request.apiKey}`;
+        const response = await (0, axios_1.default)({
+            method: 'POST',
+            url,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            data: body,
+            timeout: 120000,
+            responseType: 'stream'
+        });
+        const nodeStream = response.data;
+        let buffer = '';
+        let totalUsage;
+        for await (const chunk of nodeStream) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                try {
+                    const json = JSON.parse(trimmed.slice(6));
+                    // Handle both text and image parts in streamed chunks
+                    const parts = json.candidates?.[0]?.content?.parts || [];
+                    let chunkContent = '';
+                    for (const part of parts) {
+                        if (part.text) {
+                            chunkContent += part.text;
+                        }
+                        else if (part.inline_data?.data) {
+                            const mimeType = part.inline_data.mime_type || 'image/png';
+                            chunkContent += `\n\n![generated image](data:${mimeType};base64,${part.inline_data.data})\n\n`;
+                        }
+                    }
+                    if (json.usageMetadata) {
+                        totalUsage = {
+                            promptTokens: json.usageMetadata.promptTokenCount || 0,
+                            completionTokens: json.usageMetadata.candidatesTokenCount || 0,
+                            totalTokens: json.usageMetadata.totalTokenCount || 0
+                        };
+                    }
+                    if (chunkContent) {
+                        yield { content: chunkContent, done: false };
+                    }
+                }
+                catch {
+                    // Skip invalid JSON
+                }
+            }
+        }
+        yield { content: '', done: true, usage: totalUsage };
+    }
+}
+exports.GoogleGeminiProvider = GoogleGeminiProvider;
+/**
+ * Cohere provider using the Chat API
+ */
+class CohereProvider extends BaseProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'cohere';
+        this.displayName = 'Cohere';
+        this.baseUrl = 'https://api.cohere.ai';
+    }
+    async execute(request) {
+        const startTime = Date.now();
+        try {
+            const body = {
+                model: request.model,
+                message: request.prompt
+            };
+            if (request.systemPrompt) {
+                body.preamble = request.systemPrompt;
+            }
+            if (request.maxTokens) {
+                body.max_tokens = request.maxTokens;
+            }
+            if (request.temperature !== undefined) {
+                body.temperature = request.temperature;
+            }
+            const response = await (0, axios_1.default)({
+                method: 'POST',
+                url: `${this.baseUrl}/v1/chat`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${request.apiKey}`
+                },
+                data: body,
+                timeout: 120000
+            });
+            const data = response.data;
+            const duration = Date.now() - startTime;
+            const content = data.text || '';
+            const tokens = data.meta?.tokens || {};
+            const usage = {
+                promptTokens: tokens.input_tokens || 0,
+                completionTokens: tokens.output_tokens || 0,
+                totalTokens: (tokens.input_tokens || 0) + (tokens.output_tokens || 0)
+            };
+            return this.createSuccessResult(content, usage, duration);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return this.createErrorResult(this.extractAxiosError(error), duration);
+        }
+    }
+    async *stream(request) {
+        const body = {
+            model: request.model,
+            message: request.prompt,
+            stream: true
+        };
+        if (request.systemPrompt) {
+            body.preamble = request.systemPrompt;
+        }
+        if (request.maxTokens) {
+            body.max_tokens = request.maxTokens;
+        }
+        if (request.temperature !== undefined) {
+            body.temperature = request.temperature;
+        }
+        const response = await (0, axios_1.default)({
+            method: 'POST',
+            url: `${this.baseUrl}/v1/chat`,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${request.apiKey}`
+            },
+            data: body,
+            timeout: 120000,
+            responseType: 'stream'
+        });
+        const nodeStream = response.data;
+        let buffer = '';
+        let totalUsage;
+        for await (const chunk of nodeStream) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const json = JSON.parse(trimmed);
+                    if (json.event_type === 'text-generation') {
+                        const text = json.text || '';
+                        if (text) {
+                            yield { content: text, done: false };
+                        }
+                    }
+                    else if (json.event_type === 'stream-end' && json.response?.meta?.tokens) {
+                        const tokens = json.response.meta.tokens;
+                        totalUsage = {
+                            promptTokens: tokens.input_tokens || 0,
+                            completionTokens: tokens.output_tokens || 0,
+                            totalTokens: (tokens.input_tokens || 0) + (tokens.output_tokens || 0)
+                        };
+                    }
+                }
+                catch {
+                    // Skip invalid JSON
+                }
+            }
+        }
+        yield { content: '', done: true, usage: totalUsage };
+    }
+}
+exports.CohereProvider = CohereProvider;
+//# sourceMappingURL=base.js.map