@push.rocks/smartai 0.13.2 → 2.0.0

package/dist_ts/smartai.provider.ollama.js

@@ -0,0 +1,378 @@
+/**
+ * Convert AI SDK V3 prompt messages to Ollama's message format.
+ */
+function convertPromptToOllamaMessages(prompt) {
+    const messages = [];
+    for (const msg of prompt) {
+        if (msg.role === 'system') {
+            // System message content is a plain string in V3
+            messages.push({ role: 'system', content: msg.content });
+        }
+        else if (msg.role === 'user') {
+            let text = '';
+            const images = [];
+            for (const part of msg.content) {
+                if (part.type === 'text') {
+                    text += part.text;
+                }
+                else if (part.type === 'file' && part.mediaType?.startsWith('image/')) {
+                    // Handle image files — Ollama expects base64 images
+                    if (typeof part.data === 'string') {
+                        images.push(part.data);
+                    }
+                    else if (part.data instanceof Uint8Array) {
+                        images.push(Buffer.from(part.data).toString('base64'));
+                    }
+                }
+            }
+            const m = { role: 'user', content: text };
+            if (images.length > 0)
+                m.images = images;
+            messages.push(m);
+        }
+        else if (msg.role === 'assistant') {
+            let text = '';
+            let thinking = '';
+            const toolCalls = [];
+            for (const part of msg.content) {
+                if (part.type === 'text') {
+                    text += part.text;
+                }
+                else if (part.type === 'reasoning') {
+                    thinking += part.text;
+                }
+                else if (part.type === 'tool-call') {
+                    const args = typeof part.input === 'string'
+                        ? JSON.parse(part.input)
+                        : part.input;
+                    toolCalls.push({
+                        function: {
+                            name: part.toolName,
+                            arguments: args,
+                        },
+                    });
+                }
+            }
+            const m = { role: 'assistant', content: text };
+            if (toolCalls.length > 0)
+                m.tool_calls = toolCalls;
+            if (thinking)
+                m.thinking = thinking;
+            messages.push(m);
+        }
+        else if (msg.role === 'tool') {
+            for (const part of msg.content) {
+                if (part.type === 'tool-result') {
+                    let resultContent = '';
+                    if (part.output) {
+                        if (part.output.type === 'text') {
+                            resultContent = part.output.value;
+                        }
+                        else if (part.output.type === 'json') {
+                            resultContent = JSON.stringify(part.output.value);
+                        }
+                    }
+                    messages.push({ role: 'tool', content: resultContent });
+                }
+            }
+        }
+    }
+    return messages;
+}
+/**
+ * Convert AI SDK V3 tools to Ollama's tool format.
+ */
+function convertToolsToOllamaTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools
+        .filter((t) => t.type === 'function')
+        .map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description ?? '',
+            parameters: t.inputSchema,
+        },
+    }));
+}
+function makeUsage(promptTokens, completionTokens) {
+    return {
+        inputTokens: {
+            total: promptTokens,
+            noCache: undefined,
+            cacheRead: undefined,
+            cacheWrite: undefined,
+        },
+        outputTokens: {
+            total: completionTokens,
+            text: completionTokens,
+            reasoning: undefined,
+        },
+    };
+}
+function makeFinishReason(reason) {
+    if (reason === 'tool_calls' || reason === 'tool-calls') {
+        return { unified: 'tool-calls', raw: reason };
+    }
+    return { unified: 'stop', raw: reason ?? 'stop' };
+}
+let idCounter = 0;
+function generateId() {
+    return `ollama-${Date.now()}-${idCounter++}`;
+}
+/**
+ * Custom LanguageModelV3 implementation for Ollama.
+ * Calls Ollama's native /api/chat endpoint directly to support
+ * think, num_ctx, temperature, and other model options.
+ */
+export function createOllamaModel(options) {
+    const baseUrl = options.baseUrl ?? 'http://localhost:11434';
+    const modelId = options.model;
+    const ollamaOpts = { ...options.ollamaOptions };
+    // Apply default temperature of 0.55 for Qwen models
+    if (modelId.toLowerCase().includes('qwen') && ollamaOpts.temperature === undefined) {
+        ollamaOpts.temperature = 0.55;
+    }
+    const model = {
+        specificationVersion: 'v3',
+        provider: 'ollama',
+        modelId,
+        supportedUrls: {},
+        async doGenerate(callOptions) {
+            const messages = convertPromptToOllamaMessages(callOptions.prompt);
+            const tools = convertToolsToOllamaTools(callOptions.tools);
+            const ollamaModelOptions = { ...ollamaOpts };
+            // Override with call-level options if provided
+            if (callOptions.temperature !== undefined)
+                ollamaModelOptions.temperature = callOptions.temperature;
+            if (callOptions.topP !== undefined)
+                ollamaModelOptions.top_p = callOptions.topP;
+            if (callOptions.topK !== undefined)
+                ollamaModelOptions.top_k = callOptions.topK;
+            if (callOptions.maxOutputTokens !== undefined)
+                ollamaModelOptions.num_predict = callOptions.maxOutputTokens;
+            if (callOptions.seed !== undefined)
+                ollamaModelOptions.seed = callOptions.seed;
+            if (callOptions.stopSequences)
+                ollamaModelOptions.stop = callOptions.stopSequences;
+            // Remove think from options — it goes at the top level
+            const { think, ...modelOpts } = ollamaModelOptions;
+            const requestBody = {
+                model: modelId,
+                messages,
+                stream: false,
+                options: modelOpts,
+            };
+            // Add think parameter at the top level (Ollama API requirement)
+            if (ollamaOpts.think !== undefined) {
+                requestBody.think = ollamaOpts.think;
+            }
+            if (tools)
+                requestBody.tools = tools;
+            const response = await fetch(`${baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody),
+                signal: callOptions.abortSignal,
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`Ollama API error ${response.status}: ${body}`);
+            }
+            const result = await response.json();
+            const message = result.message;
+            // Build content array
+            const content = [];
+            // Add reasoning if present
+            if (message.thinking && typeof message.thinking === 'string') {
+                content.push({ type: 'reasoning', text: message.thinking });
+            }
+            // Add text content
+            if (message.content && typeof message.content === 'string') {
+                content.push({ type: 'text', text: message.content });
+            }
+            // Add tool calls if present
+            if (Array.isArray(message.tool_calls)) {
+                for (const tc of message.tool_calls) {
+                    const fn = tc.function;
+                    content.push({
+                        type: 'tool-call',
+                        toolCallId: generateId(),
+                        toolName: fn.name,
+                        input: JSON.stringify(fn.arguments),
+                    });
+                }
+            }
+            const finishReason = Array.isArray(message.tool_calls) && message.tool_calls.length > 0
+                ? makeFinishReason('tool_calls')
+                : makeFinishReason('stop');
+            return {
+                content,
+                finishReason,
+                usage: makeUsage(result.prompt_eval_count ?? undefined, result.eval_count ?? undefined),
+                warnings: [],
+                request: { body: requestBody },
+            };
+        },
+        async doStream(callOptions) {
+            const messages = convertPromptToOllamaMessages(callOptions.prompt);
+            const tools = convertToolsToOllamaTools(callOptions.tools);
+            const ollamaModelOptions = { ...ollamaOpts };
+            if (callOptions.temperature !== undefined)
+                ollamaModelOptions.temperature = callOptions.temperature;
+            if (callOptions.topP !== undefined)
+                ollamaModelOptions.top_p = callOptions.topP;
+            if (callOptions.topK !== undefined)
+                ollamaModelOptions.top_k = callOptions.topK;
+            if (callOptions.maxOutputTokens !== undefined)
+                ollamaModelOptions.num_predict = callOptions.maxOutputTokens;
+            if (callOptions.seed !== undefined)
+                ollamaModelOptions.seed = callOptions.seed;
+            if (callOptions.stopSequences)
+                ollamaModelOptions.stop = callOptions.stopSequences;
+            const { think, ...modelOpts } = ollamaModelOptions;
+            const requestBody = {
+                model: modelId,
+                messages,
+                stream: true,
+                options: modelOpts,
+            };
+            if (ollamaOpts.think !== undefined) {
+                requestBody.think = ollamaOpts.think;
+            }
+            if (tools)
+                requestBody.tools = tools;
+            const response = await fetch(`${baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody),
+                signal: callOptions.abortSignal,
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`Ollama API error ${response.status}: ${body}`);
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            const textId = generateId();
+            const reasoningId = generateId();
+            let textStarted = false;
+            let reasoningStarted = false;
+            let hasToolCalls = false;
+            let closed = false;
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    if (closed)
+                        return;
+                    const processLine = (line) => {
+                        if (!line.trim())
+                            return;
+                        let json;
+                        try {
+                            json = JSON.parse(line);
+                        }
+                        catch {
+                            return;
+                        }
+                        const msg = json.message;
+                        // Handle thinking/reasoning content
+                        if (msg?.thinking && typeof msg.thinking === 'string') {
+                            if (!reasoningStarted) {
+                                reasoningStarted = true;
+                                controller.enqueue({ type: 'reasoning-start', id: reasoningId });
+                            }
+                            controller.enqueue({ type: 'reasoning-delta', id: reasoningId, delta: msg.thinking });
+                        }
+                        // Handle text content
+                        if (msg?.content && typeof msg.content === 'string') {
+                            if (reasoningStarted && !textStarted) {
+                                controller.enqueue({ type: 'reasoning-end', id: reasoningId });
+                            }
+                            if (!textStarted) {
+                                textStarted = true;
+                                controller.enqueue({ type: 'text-start', id: textId });
+                            }
+                            controller.enqueue({ type: 'text-delta', id: textId, delta: msg.content });
+                        }
+                        // Handle tool calls
+                        if (Array.isArray(msg?.tool_calls)) {
+                            hasToolCalls = true;
+                            for (const tc of msg.tool_calls) {
+                                const fn = tc.function;
+                                const callId = generateId();
+                                controller.enqueue({
+                                    type: 'tool-call',
+                                    toolCallId: callId,
+                                    toolName: fn.name,
+                                    input: JSON.stringify(fn.arguments),
+                                });
+                            }
+                        }
+                        // Handle done
+                        if (json.done) {
+                            if (reasoningStarted && !textStarted) {
+                                controller.enqueue({ type: 'reasoning-end', id: reasoningId });
+                            }
+                            if (textStarted) {
+                                controller.enqueue({ type: 'text-end', id: textId });
+                            }
+                            controller.enqueue({
+                                type: 'finish',
+                                finishReason: hasToolCalls
+                                    ? makeFinishReason('tool_calls')
+                                    : makeFinishReason('stop'),
+                                usage: makeUsage(json.prompt_eval_count ?? undefined, json.eval_count ?? undefined),
+                            });
+                            closed = true;
+                            controller.close();
+                        }
+                    };
+                    try {
+                        let buffer = '';
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                if (buffer.trim())
+                                    processLine(buffer);
+                                if (!closed) {
+                                    controller.enqueue({
+                                        type: 'finish',
+                                        finishReason: makeFinishReason('stop'),
+                                        usage: makeUsage(undefined, undefined),
+                                    });
+                                    closed = true;
+                                    controller.close();
+                                }
+                                return;
+                            }
+                            buffer += decoder.decode(value, { stream: true });
+                            const lines = buffer.split('\n');
+                            buffer = lines.pop() || '';
+                            for (const line of lines) {
+                                processLine(line);
+                                if (closed)
+                                    return;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (!closed) {
+                            controller.error(error);
+                            closed = true;
+                        }
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                },
+            });
+            return {
+                stream,
+                request: { body: requestBody },
+            };
+        },
+    };
+    return model;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.provider.ollama.js","sourceRoot":"","sources":["../ts/smartai.provider.ollama.ts"],"names":[],"mappings":"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"}

package/dist_ts_audio/index.d.ts

@@ -0,0 +1,9 @@
+export interface IOpenAiTtsOptions {
+    apiKey: string;
+    text: string;
+    voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    model?: 'tts-1' | 'tts-1-hd';
+    responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac';
+    speed?: number;
+}
+export declare function textToSpeech(options: IOpenAiTtsOptions): Promise<NodeJS.ReadableStream>;

package/dist_ts_audio/index.js

@@ -0,0 +1,15 @@
+import * as plugins from './plugins.js';
+import { Readable } from 'stream';
+export async function textToSpeech(options) {
+    const client = new plugins.OpenAI({ apiKey: options.apiKey });
+    const result = await client.audio.speech.create({
+        model: options.model ?? 'tts-1',
+        voice: options.voice ?? 'alloy',
+        input: options.text,
+        response_format: options.responseFormat ?? 'mp3',
+        speed: options.speed ?? 1,
+    });
+    const stream = result.body;
+    return Readable.fromWeb(stream);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19hdWRpby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBV2xDLE1BQU0sQ0FBQyxLQUFLLFVBQVUsWUFBWSxDQUFDLE9BQTBCO0lBQzNELE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUM5RCxNQUFNLE1BQU0sR0FBRyxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUM5QyxLQUFLLEVBQUUsT0FBTyxDQUFDLEtBQUssSUFBSSxPQUFPO1FBQy9CLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxJQUFJLE9BQU87UUFDL0IsS0FBSyxFQUFFLE9BQU8sQ0FBQyxJQUFJO1FBQ25CLGVBQWUsRUFBRSxPQUFPLENBQUMsY0FBYyxJQUFJLEtBQUs7UUFDaEQsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLLElBQUksQ0FBQztLQUMxQixDQUFDLENBQUM7SUFDSCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBQzNCLE9BQU8sUUFBUSxDQUFDLE9BQU8sQ0FBQyxNQUFhLENBQUMsQ0FBQztBQUN6QyxDQUFDIn0=

package/dist_ts_audio/plugins.d.ts

@@ -0,0 +1,2 @@
+import OpenAI from 'openai';
+export { OpenAI };

package/dist_ts_audio/plugins.js

@@ -0,0 +1,3 @@
+import OpenAI from 'openai';
+export { OpenAI };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2F1ZGlvL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQzVCLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQyJ9

package/dist_ts_document/index.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+import type { ModelMessage } from 'ai';
+export interface IDocumentOptions {
+    model: LanguageModelV3;
+    systemMessage?: string;
+    userMessage: string;
+    pdfDocuments: Uint8Array[];
+    messageHistory?: ModelMessage[];
+}
+export declare function analyzeDocuments(options: IDocumentOptions): Promise<string>;
+export declare function stopSmartpdf(): Promise<void>;

package/dist_ts_document/index.js

@@ -0,0 +1,45 @@
+import * as plugins from './plugins.js';
+let smartpdfInstance = null;
+async function ensureSmartpdf() {
+    if (!smartpdfInstance) {
+        smartpdfInstance = new plugins.smartpdf.SmartPdf();
+        await smartpdfInstance.start();
+    }
+    return smartpdfInstance;
+}
+export async function analyzeDocuments(options) {
+    const pdf = await ensureSmartpdf();
+    const imagePages = [];
+    for (const doc of options.pdfDocuments) {
+        const pages = await pdf.convertPDFToPngBytes(doc);
+        imagePages.push(...pages);
+    }
+    // Filter out empty buffers
+    const validPages = imagePages.filter(page => page && page.length > 0);
+    const result = await plugins.generateText({
+        model: options.model,
+        system: options.systemMessage,
+        messages: [
+            ...(options.messageHistory ?? []),
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: options.userMessage },
+                    ...validPages.map(page => ({
+                        type: 'image',
+                        image: page,
+                        mimeType: 'image/png',
+                    })),
+                ],
+            },
+        ],
+    });
+    return result.text;
+}
+export async function stopSmartpdf() {
+    if (smartpdfInstance) {
+        await smartpdfInstance.stop();
+        smartpdfInstance = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19kb2N1bWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUl4QyxJQUFJLGdCQUFnQixHQUEwRCxJQUFJLENBQUM7QUFFbkYsS0FBSyxVQUFVLGNBQWM7SUFDM0IsSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7UUFDdEIsZ0JBQWdCLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ25ELE1BQU0sZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDakMsQ0FBQztJQUNELE9BQU8sZ0JBQWdCLENBQUM7QUFDMUIsQ0FBQztBQVVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsZ0JBQWdCLENBQUMsT0FBeUI7SUFDOUQsTUFBTSxHQUFHLEdBQUcsTUFBTSxjQUFjLEVBQUUsQ0FBQztJQUVuQyxNQUFNLFVBQVUsR0FBaUIsRUFBRSxDQUFDO0lBQ3BDLEtBQUssTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3ZDLE1BQU0sS0FBSyxHQUFHLE1BQU0sR0FBRyxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2xELFVBQVUsQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRUQsMkJBQTJCO0lBQzNCLE1BQU0sVUFBVSxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztJQUV0RSxNQUFNLE1BQU0sR0FBRyxNQUFNLE9BQU8sQ0FBQyxZQUFZLENBQUM7UUFDeEMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLE1BQU0sRUFBRSxPQUFPLENBQUMsYUFBYTtRQUM3QixRQUFRLEVBQUU7WUFDUixHQUFHLENBQUMsT0FBTyxDQUFDLGNBQWMsSUFBSSxFQUFFLENBQUM7WUFDakM7Z0JBQ0UsSUFBSSxFQUFFLE1BQU07Z0JBQ1osT0FBTyxFQUFFO29CQUNQLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLFdBQVcsRUFBRTtvQkFDM0MsR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQzt3QkFDekIsSUFBSSxFQUFFLE9BQWdCO3dCQUN0QixLQUFLLEVBQUUsSUFBSTt3QkFDWCxRQUFRLEVBQUUsV0FBb0I7cUJBQy9CLENBQUMsQ0FBQztpQkFDSjthQUNGO1NBQ0Y7S0FDRixDQUFDLENBQUM7SUFDSCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUM7QUFDckIsQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsWUFBWTtJQUNoQyxJQUFJLGdCQUFnQixFQUFFLENBQUM7UUFDckIsTUFBTSxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUM5QixnQkFBZ0IsR0FBRyxJQUFJLENBQUM7SUFDMUIsQ0FBQztBQUNILENBQUMifQ==

package/dist_ts_document/plugins.d.ts

@@ -0,0 +1,3 @@
+import { generateText } from 'ai';
+import * as smartpdf from '@push.rocks/smartpdf';
+export { generateText, smartpdf };

package/dist_ts_document/plugins.js

@@ -0,0 +1,4 @@
+import { generateText } from 'ai';
+import * as smartpdf from '@push.rocks/smartpdf';
+export { generateText, smartpdf };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2RvY3VtZW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLElBQUksQ0FBQztBQUNsQyxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLENBQUMifQ==

package/dist_ts_image/index.d.ts

@@ -0,0 +1,46 @@
+export interface IImageGenerateOptions {
+    apiKey: string;
+    prompt: string;
+    model?: 'gpt-image-1' | 'dall-e-3' | 'dall-e-2';
+    quality?: 'low' | 'medium' | 'high' | 'standard' | 'hd' | 'auto';
+    size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | '1792x1024' | '1024x1792' | 'auto';
+    style?: 'vivid' | 'natural';
+    background?: 'transparent' | 'opaque' | 'auto';
+    outputFormat?: 'png' | 'jpeg' | 'webp';
+    outputCompression?: number;
+    moderation?: 'low' | 'auto';
+    n?: number;
+    stream?: boolean;
+    partialImages?: number;
+}
+export interface IImageEditOptions {
+    apiKey: string;
+    image: Buffer;
+    prompt: string;
+    mask?: Buffer;
+    model?: 'gpt-image-1' | 'dall-e-2';
+    quality?: 'low' | 'medium' | 'high' | 'standard' | 'auto';
+    size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | 'auto';
+    background?: 'transparent' | 'opaque' | 'auto';
+    outputFormat?: 'png' | 'jpeg' | 'webp';
+    outputCompression?: number;
+    n?: number;
+    stream?: boolean;
+    partialImages?: number;
+}
+export interface IImageResponse {
+    images: Array<{
+        b64_json?: string;
+        url?: string;
+        revisedPrompt?: string;
+    }>;
+    metadata?: {
+        model: string;
+        quality?: string;
+        size?: string;
+        outputFormat?: string;
+        tokensUsed?: number;
+    };
+}
+export declare function generateImage(options: IImageGenerateOptions): Promise<IImageResponse>;
+export declare function editImage(options: IImageEditOptions): Promise<IImageResponse>;