nexus-ai-pro 0.2.0

package/dist/providers/cohere.js

@@ -0,0 +1,104 @@
+import { BaseProvider } from './base.js';
+import { generateRequestId } from '../utils/ids.js';
+import { KNOWN_MODELS } from '../types/providers.js';
+export class CohereProvider extends BaseProvider {
+    info = { name: 'cohere', isLocal: false };
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async complete(request) {
+        const startTime = Date.now();
+        const model = this.stripPrefix(request.model);
+        const response = await fetch(`${this.baseUrl()}/v2/chat`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                messages: this.extractTextContent(request.messages).map((message) => ({
+                    role: message.role === 'tool' ? 'user' : message.role,
+                    content: message.content,
+                })),
+                temperature: request.temperature,
+                max_tokens: request.maxTokens,
+                p: request.topP,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Cohere request failed: ${response.status} ${await response.text()}`);
+        }
+        const result = await response.json();
+        const content = this.extractResponseText(result);
+        const usage = result.usage?.tokens || result.usage || {};
+        const inputTokens = usage.input_tokens || usage.prompt_tokens || 0;
+        const outputTokens = usage.output_tokens || usage.completion_tokens || 0;
+        return {
+            content,
+            role: 'assistant',
+            finishReason: 'stop',
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'cohere',
+                modelUsed: result.model || model,
+                latencyMs: Date.now() - startTime,
+                tokensInput: inputTokens,
+                tokensOutput: outputTokens,
+                tokensSaved: 0,
+                estimatedCost: this.estimateCost(model, inputTokens, outputTokens),
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    stream(request) {
+        const self = this;
+        return this.createStream(async function* () {
+            try {
+                const response = await self.complete(request);
+                if (response.content) {
+                    yield { type: 'text', content: response.content };
+                }
+                yield { type: 'done', meta: response.meta };
+            }
+            catch (error) {
+                yield {
+                    type: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    async healthCheck() {
+        const response = await fetch(`${this.baseUrl()}/v2/models`, {
+            headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        });
+        return response.ok;
+    }
+    baseUrl() {
+        return this.config.baseUrl || 'https://api.cohere.com';
+    }
+    stripPrefix(model) {
+        return model.startsWith('cohere/') ? model.slice('cohere/'.length) : model;
+    }
+    extractResponseText(result) {
+        const content = result.message?.content || result.content || [];
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => typeof part === 'string' ? part : part.text || '')
+                .join('');
+        }
+        return result.text || '';
+    }
+    estimateCost(model, inputTokens, outputTokens) {
+        const caps = KNOWN_MODELS[model] || KNOWN_MODELS[`cohere/${model}`];
+        if (!caps)
+            return '$0.00';
+        return `$${(inputTokens / 1000 * caps.costPer1kInput + outputTokens / 1000 * caps.costPer1kOutput).toFixed(4)}`;
+    }
+}

package/dist/providers/google.d.ts

@@ -0,0 +1,22 @@
+import { BaseProvider, type ProviderInfo } from './base.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { GoogleProviderConfig } from '../types/config.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+export declare class GoogleProvider extends BaseProvider {
+    readonly info: ProviderInfo;
+    private config;
+    constructor(config: GoogleProviderConfig);
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+    private generate;
+    private createBody;
+    private formatMessages;
+    private formatParts;
+    private formatToolsGoogle;
+    private extractText;
+    private extractToolCalls;
+    private mapFinishReason;
+    private extractModel;
+    private baseUrl;
+    private compact;
+}

package/dist/providers/google.js

@@ -0,0 +1,226 @@
+import { BaseProvider } from './base.js';
+import { generateRequestId } from '../utils/ids.js';
+import { KNOWN_MODELS } from '../types/providers.js';
+export class GoogleProvider extends BaseProvider {
+    info = { name: 'google', isLocal: false };
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async complete(request) {
+        const startTime = Date.now();
+        const model = this.extractModel(request.model);
+        const result = await this.generate(model, request, false);
+        const latency = Date.now() - startTime;
+        const candidate = result.candidates?.[0];
+        const content = this.extractText(candidate?.content);
+        const toolCalls = this.extractToolCalls(candidate?.content);
+        const usage = result.usageMetadata || {};
+        const inputTokens = usage.promptTokenCount || 0;
+        const outputTokens = usage.candidatesTokenCount || 0;
+        const caps = KNOWN_MODELS[model];
+        return {
+            content,
+            role: 'assistant',
+            toolCalls: toolCalls.length ? toolCalls : undefined,
+            finishReason: toolCalls.length ? 'tool_calls' : this.mapFinishReason(candidate?.finishReason),
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'google',
+                modelUsed: model,
+                latencyMs: latency,
+                tokensInput: inputTokens,
+                tokensOutput: outputTokens,
+                tokensSaved: 0,
+                estimatedCost: caps
+                    ? `$${(inputTokens / 1000 * caps.costPer1kInput + outputTokens / 1000 * caps.costPer1kOutput).toFixed(4)}`
+                    : '$0.00',
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    stream(request) {
+        const self = this;
+        return this.createStream(async function* () {
+            const startTime = Date.now();
+            const model = self.extractModel(request.model);
+            const response = await self.generate(model, request, true);
+            const reader = response.body?.getReader();
+            if (!reader) {
+                yield { type: 'error', error: 'Google stream response did not include a readable body' };
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split('\n\n');
+                buffer = events.pop() || '';
+                for (const event of events) {
+                    const data = event
+                        .split('\n')
+                        .filter((line) => line.startsWith('data:'))
+                        .map((line) => line.slice(5).trim())
+                        .join('');
+                    if (!data || data === '[DONE]')
+                        continue;
+                    const parsed = JSON.parse(data);
+                    const text = self.extractText(parsed.candidates?.[0]?.content);
+                    if (text)
+                        yield { type: 'text', content: text };
+                }
+            }
+            yield {
+                type: 'done',
+                meta: {
+                    requestId: generateRequestId(),
+                    providerUsed: 'google',
+                    modelUsed: model,
+                    latencyMs: Date.now() - startTime,
+                    tokensInput: 0,
+                    tokensOutput: 0,
+                    tokensSaved: 0,
+                    estimatedCost: '$0.00',
+                    cacheHit: false,
+                    guardrailsApplied: [],
+                },
+            };
+        });
+    }
+    async generate(model, request, stream) {
+        const endpoint = stream ? 'streamGenerateContent' : 'generateContent';
+        const url = `${this.baseUrl()}/models/${encodeURIComponent(model)}:${endpoint}?key=${encodeURIComponent(this.config.apiKey)}${stream ? '&alt=sse' : ''}`;
+        const body = JSON.stringify(this.createBody(request));
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body,
+        });
+        if (!response.ok) {
+            throw new Error(`Google Gemini request failed: ${response.status} ${await response.text()}`);
+        }
+        return stream ? response : response.json();
+    }
+    createBody(request) {
+        const { systemInstruction, contents } = this.formatMessages(request.messages);
+        const generationConfig = {
+            temperature: request.temperature,
+            topP: request.topP,
+            maxOutputTokens: request.maxTokens,
+            stopSequences: request.stop ? (Array.isArray(request.stop) ? request.stop : [request.stop]) : undefined,
+        };
+        if (request.responseFormat?.type === 'json') {
+            generationConfig.responseMimeType = 'application/json';
+        }
+        else if (request.responseFormat?.type === 'json_schema' && request.responseFormat.schema) {
+            generationConfig.responseMimeType = 'application/json';
+            generationConfig.responseSchema = request.responseFormat.schema;
+        }
+        return {
+            contents,
+            systemInstruction,
+            tools: this.formatToolsGoogle(request.tools),
+            generationConfig: this.compact(generationConfig),
+        };
+    }
+    formatMessages(messages) {
+        const systemParts = [];
+        const contents = [];
+        for (const message of messages) {
+            const parts = this.formatParts(message.content);
+            if (message.role === 'system') {
+                systemParts.push(...parts);
+                continue;
+            }
+            contents.push({
+                role: message.role === 'assistant' ? 'model' : 'user',
+                parts,
+            });
+        }
+        return {
+            systemInstruction: systemParts.length ? { parts: systemParts } : undefined,
+            contents,
+        };
+    }
+    formatParts(content) {
+        if (typeof content === 'string')
+            return [{ text: content }];
+        return content.map((part) => {
+            if (part.type === 'text')
+                return { text: part.text };
+            if (part.type === 'image') {
+                const source = part.source;
+                if ('base64' in source) {
+                    return { inlineData: { mimeType: source.mimeType || 'image/png', data: source.base64 } };
+                }
+                if ('buffer' in source) {
+                    return {
+                        inlineData: {
+                            mimeType: source.mimeType || 'image/png',
+                            data: source.buffer.toString('base64'),
+                        },
+                    };
+                }
+                if ('url' in source)
+                    return { text: `[image url: ${source.url}]` };
+                return { text: '[image from path requires preprocessing]' };
+            }
+            if (part.type === 'audio' && 'transcript' in part.source) {
+                return { text: part.source.transcript };
+            }
+            return { text: `[${part.type} content is not yet supported for Google provider]` };
+        });
+    }
+    formatToolsGoogle(tools) {
+        if (!tools?.length)
+            return undefined;
+        return [{
+                functionDeclarations: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                })),
+            }];
+    }
+    extractText(content) {
+        return (content?.parts || [])
+            .filter((part) => typeof part.text === 'string')
+            .map((part) => part.text)
+            .join('');
+    }
+    extractToolCalls(content) {
+        return (content?.parts || [])
+            .filter((part) => part.functionCall)
+            .map((part) => ({
+            id: generateRequestId(),
+            type: 'function',
+            function: {
+                name: part.functionCall.name,
+                arguments: JSON.stringify(part.functionCall.args || {}),
+            },
+        }));
+    }
+    mapFinishReason(reason) {
+        if (reason === 'MAX_TOKENS')
+            return 'length';
+        if (reason === 'SAFETY' || reason === 'RECITATION')
+            return 'content_filter';
+        return 'stop';
+    }
+    extractModel(model) {
+        if (model.startsWith('google/'))
+            return model.slice('google/'.length);
+        return model;
+    }
+    baseUrl() {
+        return (this.config.baseUrl || 'https://generativelanguage.googleapis.com/v1beta').replace(/\/$/, '');
+    }
+    compact(value) {
+        return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+    }
+}

package/dist/providers/groq.d.ts

@@ -0,0 +1,15 @@
+import { OpenAIProvider } from './openai.js';
+import type { GroqProviderConfig } from '../types/config.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+export declare class GroqProvider extends OpenAIProvider {
+    readonly info: {
+        name: string;
+        isLocal: boolean;
+    };
+    constructor(config: GroqProviderConfig);
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+    private stripPrefix;
+    private estimateProviderCost;
+}

package/dist/providers/groq.js

@@ -0,0 +1,50 @@
+import { OpenAIProvider } from './openai.js';
+import { KNOWN_MODELS } from '../types/providers.js';
+export class GroqProvider extends OpenAIProvider {
+    info = { name: 'groq', isLocal: false };
+    constructor(config) {
+        super({
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl || 'https://api.groq.com/openai/v1',
+        });
+    }
+    async complete(request) {
+        const response = await super.complete({ ...request, model: this.stripPrefix(request.model) });
+        return {
+            ...response,
+            meta: {
+                ...response.meta,
+                providerUsed: 'groq',
+                modelUsed: response.meta.modelUsed || this.stripPrefix(request.model),
+                estimatedCost: this.estimateProviderCost(request.model, response.meta.tokensInput, response.meta.tokensOutput),
+            },
+        };
+    }
+    stream(request) {
+        const stream = super.stream({ ...request, model: this.stripPrefix(request.model) });
+        return this.createStream(async function* () {
+            for await (const chunk of stream) {
+                if (chunk.type === 'done') {
+                    yield {
+                        ...chunk,
+                        meta: {
+                            ...chunk.meta,
+                            providerUsed: 'groq',
+                        },
+                    };
+                    continue;
+                }
+                yield chunk;
+            }
+        });
+    }
+    stripPrefix(model) {
+        return model.startsWith('groq/') ? model.slice('groq/'.length) : model;
+    }
+    estimateProviderCost(model, inputTokens, outputTokens) {
+        const caps = KNOWN_MODELS[model];
+        if (!caps)
+            return '$0.00';
+        return `$${(inputTokens / 1000 * caps.costPer1kInput + outputTokens / 1000 * caps.costPer1kOutput).toFixed(4)}`;
+    }
+}

package/dist/providers/mistral.d.ts

@@ -0,0 +1,15 @@
+import { OpenAIProvider } from './openai.js';
+import type { MistralProviderConfig } from '../types/config.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+export declare class MistralProvider extends OpenAIProvider {
+    readonly info: {
+        name: string;
+        isLocal: boolean;
+    };
+    constructor(config: MistralProviderConfig);
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+    private stripPrefix;
+    private estimateProviderCost;
+}

package/dist/providers/mistral.js

@@ -0,0 +1,50 @@
+import { OpenAIProvider } from './openai.js';
+import { KNOWN_MODELS } from '../types/providers.js';
+export class MistralProvider extends OpenAIProvider {
+    info = { name: 'mistral', isLocal: false };
+    constructor(config) {
+        super({
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl || 'https://api.mistral.ai/v1',
+        });
+    }
+    async complete(request) {
+        const response = await super.complete({ ...request, model: this.stripPrefix(request.model) });
+        return {
+            ...response,
+            meta: {
+                ...response.meta,
+                providerUsed: 'mistral',
+                modelUsed: response.meta.modelUsed || this.stripPrefix(request.model),
+                estimatedCost: this.estimateProviderCost(request.model, response.meta.tokensInput, response.meta.tokensOutput),
+            },
+        };
+    }
+    stream(request) {
+        const stream = super.stream({ ...request, model: this.stripPrefix(request.model) });
+        return this.createStream(async function* () {
+            for await (const chunk of stream) {
+                if (chunk.type === 'done') {
+                    yield {
+                        ...chunk,
+                        meta: {
+                            ...chunk.meta,
+                            providerUsed: 'mistral',
+                        },
+                    };
+                    continue;
+                }
+                yield chunk;
+            }
+        });
+    }
+    stripPrefix(model) {
+        return model.startsWith('mistral/') ? model.slice('mistral/'.length) : model;
+    }
+    estimateProviderCost(model, inputTokens, outputTokens) {
+        const caps = KNOWN_MODELS[model];
+        if (!caps)
+            return '$0.00';
+        return `$${(inputTokens / 1000 * caps.costPer1kInput + outputTokens / 1000 * caps.costPer1kOutput).toFixed(4)}`;
+    }
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,15 @@
+import { BaseProvider, type ProviderInfo } from './base.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+import type { OllamaProviderConfig } from '../types/config.js';
+export declare class OllamaProvider extends BaseProvider {
+    readonly info: ProviderInfo;
+    private client;
+    private config;
+    constructor(config: OllamaProviderConfig);
+    private getClient;
+    private formatMessages;
+    private extractModel;
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+}

package/dist/providers/ollama.js

@@ -0,0 +1,108 @@
+import { BaseProvider } from './base.js';
+import { generateRequestId } from '../utils/ids.js';
+export class OllamaProvider extends BaseProvider {
+    info = { name: 'ollama', isLocal: true };
+    client;
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async getClient() {
+        if (!this.client) {
+            const { Ollama } = await import('ollama');
+            this.client = new Ollama({ host: this.config.baseUrl || 'http://localhost:11434' });
+        }
+        return this.client;
+    }
+    formatMessages(messages) {
+        return messages.map((msg) => ({
+            role: msg.role,
+            content: typeof msg.content === 'string'
+                ? msg.content
+                : msg.content
+                    .filter((p) => p.type === 'text')
+                    .map((p) => p.text)
+                    .join('\n'),
+        }));
+    }
+    extractModel(model) {
+        // Support "ollama/llama3.2" syntax — strip prefix
+        if (model.startsWith('ollama/'))
+            return model.slice(7);
+        return model;
+    }
+    async complete(request) {
+        const client = await this.getClient();
+        const startTime = Date.now();
+        const model = this.extractModel(request.model);
+        const result = await client.chat({
+            model,
+            messages: this.formatMessages(request.messages),
+            format: request.responseFormat?.type === 'json' ? 'json' : request.responseFormat?.schema,
+            options: {
+                temperature: request.temperature,
+                top_p: request.topP,
+                stop: request.stop ? (Array.isArray(request.stop) ? request.stop : [request.stop]) : undefined,
+            },
+        });
+        const latency = Date.now() - startTime;
+        return {
+            content: result.message?.content || '',
+            role: 'assistant',
+            finishReason: 'stop',
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'ollama',
+                modelUsed: model,
+                latencyMs: latency,
+                tokensInput: result.prompt_eval_count || 0,
+                tokensOutput: result.eval_count || 0,
+                tokensSaved: 0,
+                estimatedCost: '$0.00',
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    stream(request) {
+        const self = this;
+        return this.createStream(async function* () {
+            const client = await self.getClient();
+            const startTime = Date.now();
+            const model = self.extractModel(request.model);
+            const stream = await client.chat({
+                model,
+                messages: self.formatMessages(request.messages),
+                stream: true,
+                format: request.responseFormat?.type === 'json' ? 'json' : request.responseFormat?.schema,
+                options: {
+                    temperature: request.temperature,
+                    top_p: request.topP,
+                },
+            });
+            for await (const chunk of stream) {
+                if (chunk.message?.content) {
+                    yield { type: 'text', content: chunk.message.content };
+                }
+                if (chunk.done) {
+                    yield {
+                        type: 'done',
+                        meta: {
+                            requestId: generateRequestId(),
+                            providerUsed: 'ollama',
+                            modelUsed: model,
+                            latencyMs: Date.now() - startTime,
+                            tokensInput: chunk.prompt_eval_count || 0,
+                            tokensOutput: chunk.eval_count || 0,
+                            tokensSaved: 0,
+                            estimatedCost: '$0.00',
+                            cacheHit: false,
+                            guardrailsApplied: [],
+                        },
+                    };
+                }
+            }
+        });
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,21 @@
+import { BaseProvider, type ProviderInfo } from './base.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+import type { OpenAIProviderConfig } from '../types/config.js';
+export declare class OpenAIProvider extends BaseProvider {
+    readonly info: ProviderInfo;
+    private client;
+    private config;
+    constructor(config: OpenAIProviderConfig);
+    private getClient;
+    private formatMessages;
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+    private mapFinishReason;
+    private completeResponses;
+    private requiresResponsesApi;
+    private formatResponsesInput;
+    private formatResponsesTools;
+    private extractResponsesText;
+    private estimateCost;
+}