@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/llm/providers/openai-compatible.js

@@ -0,0 +1,289 @@
+/**
+ * Generic OpenAI-Compatible Provider
+ * Works with any provider that implements the OpenAI chat completions API:
+ * Groq, Together AI, DeepSeek, Fireworks AI, Perplexity, Mistral AI, etc.
+ */
+import OpenAI from 'openai';
+import { BaseProvider, getTextContent, } from '../types';
+export class OpenAICompatibleProvider extends BaseProvider {
+    name;
+    client;
+    defaultModel;
+    constructor(config) {
+        super();
+        this.name = config.name;
+        this.defaultModel = config.defaultModel;
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            defaultHeaders: config.defaultHeaders,
+        });
+    }
+    async complete(request) {
+        const messages = this.convertMessages(request.messages);
+        const response = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stop: request.stopSequences,
+            response_format: request.responseFormat,
+        });
+        const choice = response.choices?.[0];
+        if (!choice) {
+            throw new Error(`${this.name} response missing choices`);
+        }
+        return {
+            content: choice.message.content || '',
+            toolCalls: choice.message.tool_calls?.map(tc => this.convertToolCall(tc)),
+            usage: {
+                promptTokens: response.usage?.prompt_tokens || 0,
+                completionTokens: response.usage?.completion_tokens || 0,
+                totalTokens: response.usage?.total_tokens || 0,
+            },
+            model: response.model,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+        };
+    }
+    async *stream(request) {
+        const messages = this.convertMessages(request.messages);
+        const stream = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stop: request.stopSequences,
+            stream: true,
+        });
+        // Accumulator for tool calls across chunks
+        const toolCallAccumulator = new Map();
+        let usage;
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            const finishReason = chunk.choices[0]?.finish_reason;
+            if (delta?.content) {
+                yield {
+                    content: delta.content,
+                    done: false,
+                };
+            }
+            if (delta?.tool_calls) {
+                // Accumulate tool calls across chunks
+                for (const tc of delta.tool_calls) {
+                    const index = tc.index ?? 0;
+                    const existing = toolCallAccumulator.get(index);
+                    if (existing) {
+                        // Append arguments to existing tool call
+                        if (tc.function?.arguments) {
+                            existing.arguments += tc.function.arguments;
+                        }
+                    }
+                    else {
+                        // Initialize new tool call entry
+                        toolCallAccumulator.set(index, {
+                            id: tc.id || '',
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        });
+                    }
+                }
+            }
+            // Accumulate usage (do not yield until done)
+            if (chunk.usage) {
+                usage = {
+                    promptTokens: chunk.usage.prompt_tokens || 0,
+                    completionTokens: chunk.usage.completion_tokens || 0,
+                    totalTokens: chunk.usage.total_tokens || 0,
+                };
+            }
+            if (finishReason) {
+                const toolCalls = toolCallAccumulator.size > 0
+                    ? Array.from(toolCallAccumulator.values()).map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }))
+                    : undefined;
+                yield { done: true, toolCalls, usage };
+                return;
+            }
+        }
+    }
+    async completeWithTools(request) {
+        const messages = this.convertMessages(request.messages);
+        const response = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            tools: request.tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                },
+            })),
+            tool_choice: request.toolChoice,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+        });
+        const choice = response.choices?.[0];
+        if (!choice) {
+            throw new Error(`${this.name} response missing choices`);
+        }
+        return {
+            content: choice.message.content || '',
+            toolCalls: choice.message.tool_calls?.map(tc => this.convertToolCall(tc)),
+            usage: {
+                promptTokens: response.usage?.prompt_tokens || 0,
+                completionTokens: response.usage?.completion_tokens || 0,
+                totalTokens: response.usage?.total_tokens || 0,
+            },
+            model: response.model,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+        };
+    }
+    /**
+     * Stream a chat completion with tool calling support.
+     * Uses the OpenAI SDK streaming interface with tools, accumulating tool calls
+     * and yielding text deltas incrementally.
+     */
+    async *streamWithTools(request) {
+        const messages = this.convertMessages(request.messages);
+        const stream = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            tools: request.tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                },
+            })),
+            tool_choice: request.toolChoice,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        const toolCallAccumulator = new Map();
+        let usage;
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            const finishReason = chunk.choices[0]?.finish_reason;
+            if (delta?.content) {
+                yield { content: delta.content, done: false };
+            }
+            if (delta?.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const index = tc.index ?? 0;
+                    const existing = toolCallAccumulator.get(index);
+                    if (existing) {
+                        if (tc.function?.arguments) {
+                            existing.arguments += tc.function.arguments;
+                        }
+                    }
+                    else {
+                        toolCallAccumulator.set(index, {
+                            id: tc.id || '',
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        });
+                    }
+                }
+            }
+            if (chunk.usage) {
+                usage = {
+                    promptTokens: chunk.usage.prompt_tokens || 0,
+                    completionTokens: chunk.usage.completion_tokens || 0,
+                    totalTokens: chunk.usage.total_tokens || 0,
+                };
+            }
+            if (finishReason) {
+                const toolCalls = toolCallAccumulator.size > 0
+                    ? Array.from(toolCallAccumulator.values()).map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }))
+                    : undefined;
+                yield { done: true, toolCalls, usage };
+                return;
+            }
+        }
+    }
+    async countTokens(text) {
+        // Approximation: ~4 characters per token
+        return Math.ceil(text.length / 4);
+    }
+    getMaxTokens(_model) {
+        return 4096;
+    }
+    async listModels() {
+        try {
+            const response = await this.client.models.list();
+            const ids = [];
+            for await (const model of response) {
+                if (model.id) {
+                    ids.push(model.id);
+                }
+            }
+            if (ids.length > 0) {
+                return ids;
+            }
+        }
+        catch {
+            // Server does not support /v1/models or is unreachable -- fall back
+        }
+        return [this.defaultModel];
+    }
+    /**
+     * Convert messages to OpenAI-compatible format
+     */
+    convertMessages(messages) {
+        return messages.map(m => {
+            if (m.role === 'tool') {
+                // Tool result message
+                return {
+                    role: 'tool',
+                    content: getTextContent(m.content),
+                    tool_call_id: m.toolCallId,
+                };
+            }
+            if (m.role === 'assistant' && m.toolCalls && m.toolCalls.length > 0) {
+                // Assistant message with tool calls
+                return {
+                    role: 'assistant',
+                    content: getTextContent(m.content) || null,
+                    tool_calls: m.toolCalls.map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function.name,
+                            arguments: tc.function.arguments,
+                        },
+                    })),
+                };
+            }
+            // Regular message
+            return {
+                role: m.role,
+                content: getTextContent(m.content),
+            };
+        });
+    }
+    /**
+     * Convert OpenAI tool call to standard format
+     */
+    convertToolCall(tc) {
+        const fn = 'function' in tc ? tc.function : { name: '', arguments: '{}' };
+        return {
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: fn.name,
+                arguments: fn.arguments,
+            },
+        };
+    }
+}

package/dist/src/llm/providers/openai.js

@@ -0,0 +1,284 @@
+/**
+ * OpenAI Provider
+ * Supports GPT-4o, GPT-4o-mini, GPT-4-turbo
+ */
+import OpenAI from 'openai';
+import { encode } from 'gpt-tokenizer';
+import { BaseProvider, getTextContent, } from '../types';
+import { getProviderApiKey } from '../auth-bridge';
+export class OpenAIProvider extends BaseProvider {
+    name = 'openai';
+    client;
+    defaultModel = 'gpt-4o';
+    constructor(apiKey) {
+        super();
+        this.client = new OpenAI({
+            apiKey: apiKey || getProviderApiKey('openai') || process.env.OPENAI_API_KEY,
+        });
+    }
+    async complete(request) {
+        const messages = this.convertMessages(request.messages);
+        const response = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stop: request.stopSequences,
+            response_format: request.responseFormat,
+        });
+        const choice = response.choices?.[0];
+        if (!choice) {
+            throw new Error('OpenAI response missing choices');
+        }
+        return {
+            content: choice.message.content || '',
+            toolCalls: choice.message.tool_calls?.map(tc => this.convertToolCall(tc)),
+            usage: {
+                promptTokens: response.usage?.prompt_tokens || 0,
+                completionTokens: response.usage?.completion_tokens || 0,
+                totalTokens: response.usage?.total_tokens || 0,
+            },
+            model: response.model,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+        };
+    }
+    async *stream(request) {
+        const messages = this.convertMessages(request.messages);
+        const stream = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stop: request.stopSequences,
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        // Accumulator for tool calls across chunks
+        const toolCallAccumulator = new Map();
+        let usage;
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            const finishReason = chunk.choices[0]?.finish_reason;
+            if (delta?.content) {
+                yield {
+                    content: delta.content,
+                    done: false,
+                };
+            }
+            if (delta?.tool_calls) {
+                // Accumulate tool calls across chunks (do not yield until done)
+                for (const tc of delta.tool_calls) {
+                    const index = tc.index ?? 0;
+                    const existing = toolCallAccumulator.get(index);
+                    if (existing) {
+                        // Append arguments to existing tool call
+                        if (tc.function?.arguments) {
+                            existing.arguments += tc.function.arguments;
+                        }
+                    }
+                    else {
+                        // Initialize new tool call entry
+                        toolCallAccumulator.set(index, {
+                            id: tc.id || '',
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        });
+                    }
+                }
+            }
+            // Accumulate usage (do not yield until done)
+            if (chunk.usage) {
+                usage = {
+                    promptTokens: chunk.usage.prompt_tokens || 0,
+                    completionTokens: chunk.usage.completion_tokens || 0,
+                    totalTokens: chunk.usage.total_tokens || 0,
+                };
+            }
+            if (finishReason) {
+                const toolCalls = toolCallAccumulator.size > 0
+                    ? Array.from(toolCallAccumulator.values()).map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }))
+                    : undefined;
+                yield { done: true, toolCalls, usage };
+                return;
+            }
+        }
+    }
+    async completeWithTools(request) {
+        const messages = this.convertMessages(request.messages);
+        const response = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            tools: request.tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                },
+            })),
+            tool_choice: request.toolChoice,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+        });
+        const choice = response.choices?.[0];
+        if (!choice) {
+            throw new Error('OpenAI response missing choices');
+        }
+        return {
+            content: choice.message.content || '',
+            toolCalls: choice.message.tool_calls?.map(tc => this.convertToolCall(tc)),
+            usage: {
+                promptTokens: response.usage?.prompt_tokens || 0,
+                completionTokens: response.usage?.completion_tokens || 0,
+                totalTokens: response.usage?.total_tokens || 0,
+            },
+            model: response.model,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+        };
+    }
+    async *streamWithTools(request) {
+        const messages = this.convertMessages(request.messages);
+        const stream = await this.client.chat.completions.create({
+            model: request.model || this.defaultModel,
+            messages,
+            tools: request.tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters,
+                },
+            })),
+            tool_choice: request.toolChoice,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            stream: true,
+            stream_options: { include_usage: true },
+        });
+        const toolCallAccumulator = new Map();
+        let usage;
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            const finishReason = chunk.choices[0]?.finish_reason;
+            if (delta?.content) {
+                yield { content: delta.content, done: false };
+            }
+            if (delta?.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const index = tc.index ?? 0;
+                    const existing = toolCallAccumulator.get(index);
+                    if (existing) {
+                        if (tc.function?.arguments) {
+                            existing.arguments += tc.function.arguments;
+                        }
+                    }
+                    else {
+                        toolCallAccumulator.set(index, {
+                            id: tc.id || '',
+                            name: tc.function?.name || '',
+                            arguments: tc.function?.arguments || '',
+                        });
+                    }
+                }
+            }
+            if (chunk.usage) {
+                usage = {
+                    promptTokens: chunk.usage.prompt_tokens || 0,
+                    completionTokens: chunk.usage.completion_tokens || 0,
+                    totalTokens: chunk.usage.total_tokens || 0,
+                };
+            }
+            if (finishReason) {
+                const toolCalls = toolCallAccumulator.size > 0
+                    ? Array.from(toolCallAccumulator.values()).map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }))
+                    : undefined;
+                yield { done: true, toolCalls, usage };
+                return;
+            }
+        }
+    }
+    async countTokens(text) {
+        // Use gpt-tokenizer for accurate count
+        return encode(text).length;
+    }
+    getMaxTokens(model) {
+        const limits = {
+            'gpt-4o': 16384,
+            'gpt-4o-2024-11-20': 16384,
+            'gpt-4o-mini': 16384,
+            'gpt-4o-mini-2024-07-18': 16384,
+            'gpt-4-turbo': 4096,
+            'gpt-4-turbo-2024-04-09': 4096,
+            'gpt-4': 8192,
+            'gpt-3.5-turbo': 4096,
+        };
+        return limits[model] || 4096;
+    }
+    async listModels() {
+        return [
+            'gpt-4o',
+            'gpt-4o-2024-11-20',
+            'gpt-4o-mini',
+            'gpt-4o-mini-2024-07-18',
+            'gpt-4-turbo',
+            'gpt-4',
+        ];
+    }
+    /**
+     * Convert messages to OpenAI format
+     */
+    convertMessages(messages) {
+        return messages.map(m => {
+            if (m.role === 'tool') {
+                // Tool result message
+                return {
+                    role: 'tool',
+                    content: getTextContent(m.content),
+                    tool_call_id: m.toolCallId,
+                };
+            }
+            if (m.role === 'assistant' && m.toolCalls && m.toolCalls.length > 0) {
+                // Assistant message with tool calls
+                return {
+                    role: 'assistant',
+                    content: getTextContent(m.content) || null,
+                    tool_calls: m.toolCalls.map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function.name,
+                            arguments: tc.function.arguments,
+                        },
+                    })),
+                };
+            }
+            // Regular message
+            return {
+                role: m.role,
+                content: getTextContent(m.content),
+            };
+        });
+    }
+    /**
+     * Convert OpenAI tool call to standard format
+     */
+    convertToolCall(tc) {
+        const fn = 'function' in tc ? tc.function : { name: '', arguments: '{}' };
+        return {
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: fn.name,
+                arguments: fn.arguments,
+            },
+        };
+    }
+}