nexus-ai-pro 0.2.0

package/dist/providers/openai.js

@@ -0,0 +1,304 @@
+import { BaseProvider } from './base.js';
+import { generateRequestId } from '../utils/ids.js';
+import { KNOWN_MODELS } from '../types/providers.js';
+export class OpenAIProvider extends BaseProvider {
+    info = { name: 'openai', isLocal: false };
+    client;
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async getClient() {
+        if (!this.client) {
+            const { default: OpenAI } = await import('openai');
+            this.client = new OpenAI({
+                apiKey: this.config.apiKey,
+                baseURL: this.config.baseUrl,
+                organization: this.config.organization,
+            });
+        }
+        return this.client;
+    }
+    formatMessages(messages) {
+        return messages.map((msg) => {
+            if (typeof msg.content === 'string') {
+                return { role: msg.role, content: msg.content };
+            }
+            const parts = msg.content.map((part) => {
+                switch (part.type) {
+                    case 'text':
+                        return { type: 'text', text: part.text };
+                    case 'image': {
+                        const src = part.source;
+                        if ('url' in src) {
+                            return { type: 'image_url', image_url: { url: src.url } };
+                        }
+                        if ('base64' in src) {
+                            const mime = src.mimeType || 'image/png';
+                            return { type: 'image_url', image_url: { url: `data:${mime};base64,${src.base64}` } };
+                        }
+                        if ('buffer' in src) {
+                            const mime = src.mimeType || 'image/png';
+                            const b64 = src.buffer.toString('base64');
+                            return { type: 'image_url', image_url: { url: `data:${mime};base64,${b64}` } };
+                        }
+                        return { type: 'text', text: '[image from path — requires preprocessing]' };
+                    }
+                    default:
+                        return { type: 'text', text: `[${part.type} content — not yet supported for this provider]` };
+                }
+            });
+            return { role: msg.role, content: parts };
+        });
+    }
+    async complete(request) {
+        if (this.requiresResponsesApi(request.model)) {
+            return this.completeResponses(request);
+        }
+        const client = await this.getClient();
+        const startTime = Date.now();
+        const params = {
+            model: request.model,
+            messages: this.formatMessages(request.messages),
+            temperature: request.temperature,
+            max_tokens: request.maxTokens,
+            top_p: request.topP,
+            logit_bias: request.logitBias,
+            stop: request.stop,
+        };
+        if (request.responseFormat?.type === 'json') {
+            params.response_format = { type: 'json_object' };
+        }
+        else if (request.responseFormat?.type === 'json_schema' && request.responseFormat.schema) {
+            params.response_format = {
+                type: 'json_schema',
+                json_schema: {
+                    name: 'nexus_response',
+                    schema: request.responseFormat.schema,
+                    strict: true,
+                },
+            };
+        }
+        const tools = this.formatTools(request.tools);
+        if (tools)
+            params.tools = tools;
+        const result = await client.chat.completions.create(params);
+        const choice = result.choices[0];
+        const latency = Date.now() - startTime;
+        const toolCalls = choice.message.tool_calls?.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.function.name, arguments: tc.function.arguments },
+        }));
+        const inputCost = (result.usage?.prompt_tokens || 0) / 1000;
+        const outputCost = (result.usage?.completion_tokens || 0) / 1000;
+        return {
+            content: choice.message.content || '',
+            role: 'assistant',
+            toolCalls,
+            finishReason: this.mapFinishReason(choice.finish_reason),
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'openai',
+                modelUsed: result.model,
+                latencyMs: latency,
+                tokensInput: result.usage?.prompt_tokens || 0,
+                tokensOutput: result.usage?.completion_tokens || 0,
+                tokensSaved: 0,
+                estimatedCost: `$${(inputCost * 0.0025 + outputCost * 0.01).toFixed(4)}`,
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    stream(request) {
+        const self = this;
+        return this.createStream(async function* () {
+            if (self.requiresResponsesApi(request.model)) {
+                yield {
+                    type: 'error',
+                    error: `Model "${request.model}" requires the OpenAI Responses API. Streaming for Responses-only models is not implemented yet.`,
+                };
+                return;
+            }
+            const client = await self.getClient();
+            const startTime = Date.now();
+            const params = {
+                model: request.model,
+                messages: self.formatMessages(request.messages),
+                temperature: request.temperature,
+                max_tokens: request.maxTokens,
+                top_p: request.topP,
+                logit_bias: request.logitBias,
+                stop: request.stop,
+                stream: true,
+            };
+            if (request.responseFormat?.type === 'json') {
+                params.response_format = { type: 'json_object' };
+            }
+            else if (request.responseFormat?.type === 'json_schema' && request.responseFormat.schema) {
+                params.response_format = {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'nexus_response',
+                        schema: request.responseFormat.schema,
+                        strict: true,
+                    },
+                };
+            }
+            const tools = self.formatTools(request.tools);
+            if (tools)
+                params.tools = tools;
+            const stream = await client.chat.completions.create(params);
+            let fullContent = '';
+            const toolCallBuffers = new Map();
+            for await (const chunk of stream) {
+                const delta = chunk.choices?.[0]?.delta;
+                if (!delta)
+                    continue;
+                if (delta.content) {
+                    fullContent += delta.content;
+                    yield { type: 'text', content: delta.content };
+                }
+                if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        if (!toolCallBuffers.has(tc.index)) {
+                            toolCallBuffers.set(tc.index, { id: tc.id || '', name: '', args: '' });
+                        }
+                        const buf = toolCallBuffers.get(tc.index);
+                        if (tc.id)
+                            buf.id = tc.id;
+                        if (tc.function?.name)
+                            buf.name += tc.function.name;
+                        if (tc.function?.arguments)
+                            buf.args += tc.function.arguments;
+                    }
+                }
+                if (chunk.choices?.[0]?.finish_reason) {
+                    for (const [, buf] of toolCallBuffers) {
+                        yield {
+                            type: 'tool_call',
+                            toolCall: {
+                                id: buf.id,
+                                type: 'function',
+                                function: { name: buf.name, arguments: buf.args },
+                            },
+                        };
+                    }
+                    yield {
+                        type: 'done',
+                        meta: {
+                            requestId: generateRequestId(),
+                            providerUsed: 'openai',
+                            modelUsed: request.model,
+                            latencyMs: Date.now() - startTime,
+                            tokensInput: 0,
+                            tokensOutput: 0,
+                            tokensSaved: 0,
+                            estimatedCost: '$0.00',
+                            cacheHit: false,
+                            guardrailsApplied: [],
+                        },
+                    };
+                }
+            }
+        });
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'stop': return 'stop';
+            case 'tool_calls': return 'tool_calls';
+            case 'length': return 'length';
+            case 'content_filter': return 'content_filter';
+            default: return 'stop';
+        }
+    }
+    async completeResponses(request) {
+        const client = await this.getClient();
+        if (!client.responses?.create) {
+            throw new Error(`Model "${request.model}" requires the OpenAI Responses API, but the installed openai SDK does not expose client.responses.create. Upgrade the openai package.`);
+        }
+        const startTime = Date.now();
+        const params = {
+            model: request.model,
+            input: this.formatResponsesInput(request.messages),
+            temperature: request.temperature,
+            max_output_tokens: request.maxTokens,
+            top_p: request.topP,
+            store: false,
+        };
+        const tools = this.formatResponsesTools(request.tools);
+        if (tools)
+            params.tools = tools;
+        if (request.responseFormat?.type === 'json') {
+            params.text = { format: { type: 'json_object' } };
+        }
+        else if (request.responseFormat?.type === 'json_schema' && request.responseFormat.schema) {
+            params.text = {
+                format: {
+                    type: 'json_schema',
+                    name: 'nexus_response',
+                    schema: request.responseFormat.schema,
+                    strict: true,
+                },
+            };
+        }
+        const result = await client.responses.create(params);
+        const latency = Date.now() - startTime;
+        const content = result.output_text || this.extractResponsesText(result);
+        const usage = result.usage || {};
+        const inputTokens = usage.input_tokens || 0;
+        const outputTokens = usage.output_tokens || 0;
+        return {
+            content,
+            role: 'assistant',
+            finishReason: result.status === 'incomplete' ? 'length' : 'stop',
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'openai',
+                modelUsed: result.model || request.model,
+                latencyMs: latency,
+                tokensInput: inputTokens,
+                tokensOutput: outputTokens,
+                tokensSaved: 0,
+                estimatedCost: this.estimateCost(request.model, inputTokens, outputTokens),
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    requiresResponsesApi(model) {
+        const endpoints = KNOWN_MODELS[model]?.endpoints;
+        return Boolean(endpoints?.includes('responses') && !endpoints.includes('chat'));
+    }
+    formatResponsesInput(messages) {
+        return this.extractTextContent(messages).map((message) => ({
+            role: message.role === 'tool' ? 'user' : message.role,
+            content: message.content,
+        }));
+    }
+    formatResponsesTools(tools) {
+        if (!tools?.length)
+            return undefined;
+        return tools.map((tool) => ({
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+    }
+    extractResponsesText(result) {
+        return (result.output || [])
+            .flatMap((item) => item.content || [])
+            .filter((part) => part.type === 'output_text' || part.type === 'text')
+            .map((part) => part.text || '')
+            .join('');
+    }
+    estimateCost(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/openrouter.d.ts

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

package/dist/providers/openrouter.js

@@ -0,0 +1,19 @@
+import { OpenAIProvider } from './openai.js';
+export class OpenRouterProvider extends OpenAIProvider {
+    info = { name: 'openrouter', isLocal: false };
+    constructor(config) {
+        super({
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl || 'https://openrouter.ai/api/v1',
+        });
+    }
+    async complete(request) {
+        return super.complete({ ...request, model: this.stripPrefix(request.model) });
+    }
+    stream(request) {
+        return super.stream({ ...request, model: this.stripPrefix(request.model) });
+    }
+    stripPrefix(model) {
+        return model.startsWith('openrouter/') ? model.slice('openrouter/'.length) : model;
+    }
+}

package/dist/rag/file-ingestion.d.ts

@@ -0,0 +1,20 @@
+import { type FileUpload, type UploadScannerOptions } from '../security/upload-scanner.js';
+import { type IngestionOptions, type IngestionResult } from './ingestion.js';
+export interface FileTextExtractor {
+    supports(file: FileUpload): boolean;
+    extract(file: FileUpload): Promise<string> | string;
+}
+export interface FileIngestionOptions extends IngestionOptions {
+    scan?: UploadScannerOptions;
+    extractors?: FileTextExtractor[];
+}
+export interface FileIngestionResult extends IngestionResult {
+    scannedFiles: number;
+    skippedFiles: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+export declare function ingestFilesAfterScan(files: FileUpload[], options?: FileIngestionOptions): Promise<FileIngestionResult>;
+export declare function createPdfExtractor(extractPdfText: (file: FileUpload) => Promise<string> | string): FileTextExtractor;
+export declare function createOcrExtractor(ocrImage: (file: FileUpload) => Promise<string> | string, mimeTypes?: string[]): FileTextExtractor;

package/dist/rag/file-ingestion.js

@@ -0,0 +1,55 @@
+import { scanUploads } from '../security/upload-scanner.js';
+import { ingestDocuments } from './ingestion.js';
+export async function ingestFilesAfterScan(files, options = {}) {
+    const scan = scanUploads(files, options.scan);
+    if (!scan.ok) {
+        throw new Error(`Upload scan failed: ${scan.findings.map((finding) => `${finding.fileName}: ${finding.message}`).join('; ')}`);
+    }
+    const documents = [];
+    const skippedFiles = [];
+    for (const file of files) {
+        const extractor = options.extractors?.find((item) => item.supports(file));
+        if (extractor) {
+            documents.push({
+                id: file.name,
+                source: file.name,
+                text: await extractor.extract(file),
+                metadata: { mimeType: file.mimeType, sizeBytes: file.sizeBytes },
+            });
+            continue;
+        }
+        if (typeof file.content === 'string' && isTextMime(file.mimeType)) {
+            documents.push({
+                id: file.name,
+                source: file.name,
+                text: file.content,
+                metadata: { mimeType: file.mimeType, sizeBytes: file.sizeBytes },
+            });
+            continue;
+        }
+        skippedFiles.push({ name: file.name, reason: 'No extractor available for file type' });
+    }
+    const result = ingestDocuments(documents, options);
+    return {
+        ...result,
+        scannedFiles: files.length,
+        skippedFiles,
+    };
+}
+export function createPdfExtractor(extractPdfText) {
+    return {
+        supports: (file) => file.mimeType === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf'),
+        extract: extractPdfText,
+    };
+}
+export function createOcrExtractor(ocrImage, mimeTypes = ['image/png', 'image/jpeg', 'image/webp']) {
+    return {
+        supports: (file) => Boolean(file.mimeType && mimeTypes.includes(file.mimeType)),
+        extract: ocrImage,
+    };
+}
+function isTextMime(mimeType) {
+    if (!mimeType)
+        return true;
+    return mimeType.startsWith('text/') || ['application/json', 'application/xml', 'application/markdown'].includes(mimeType);
+}

package/dist/rag/ingestion.d.ts

@@ -0,0 +1,21 @@
+import type { RagChunk } from '../hallucination/rag.js';
+export interface DocumentSource {
+    id?: string;
+    text: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface IngestionOptions {
+    chunkSize?: number;
+    overlap?: number;
+    splitOnMarkdownHeadings?: boolean;
+}
+export interface IngestionResult {
+    chunks: RagChunk[];
+    documents: number;
+    totalCharacters: number;
+}
+export declare function ingestDocuments(documents: DocumentSource[], options?: IngestionOptions): IngestionResult;
+export declare function ingestText(text: string, options?: IngestionOptions & {
+    source?: string;
+}): IngestionResult;

package/dist/rag/ingestion.js

@@ -0,0 +1,47 @@
+export function ingestDocuments(documents, options = {}) {
+    const chunks = [];
+    const chunkSize = options.chunkSize || 1200;
+    const overlap = Math.min(options.overlap || 150, Math.max(0, chunkSize - 1));
+    for (const [docIndex, doc] of documents.entries()) {
+        const sections = options.splitOnMarkdownHeadings
+            ? splitMarkdownSections(doc.text)
+            : [doc.text];
+        for (const [sectionIndex, section] of sections.entries()) {
+            let start = 0;
+            let chunkIndex = 0;
+            while (start < section.length) {
+                const end = Math.min(section.length, start + chunkSize);
+                const content = section.slice(start, end).trim();
+                if (content) {
+                    chunks.push({
+                        id: `${doc.id || `doc-${docIndex + 1}`}-${sectionIndex + 1}-${chunkIndex + 1}`,
+                        content,
+                        source: doc.source,
+                        metadata: {
+                            ...doc.metadata,
+                            documentId: doc.id,
+                            sectionIndex,
+                            chunkIndex,
+                        },
+                    });
+                }
+                if (end >= section.length)
+                    break;
+                start = Math.max(0, end - overlap);
+                chunkIndex += 1;
+            }
+        }
+    }
+    return {
+        chunks,
+        documents: documents.length,
+        totalCharacters: documents.reduce((sum, doc) => sum + doc.text.length, 0),
+    };
+}
+export function ingestText(text, options = {}) {
+    return ingestDocuments([{ text, source: options.source }], options);
+}
+function splitMarkdownSections(text) {
+    const sections = text.split(/(?=^#{1,6}\s+)/m).map((section) => section.trim()).filter(Boolean);
+    return sections.length ? sections : [text];
+}

package/dist/router/auto-router.d.ts

@@ -0,0 +1,17 @@
+import type { RouterContext, RouteDecision } from './types.js';
+export declare class AutoRouter {
+    route(ctx: RouterContext): RouteDecision;
+    private getCandidates;
+    private score;
+    private localFallbackCapabilities;
+    private costScore;
+    private speedScore;
+    private qualityScore;
+    private preferencesForProvider;
+    private isAllowed;
+    private matchesRequirements;
+    private matchesModelPattern;
+    private isProviderRunnable;
+    private healthScore;
+}
+export declare function routeDirectModel(model: string, ctx: RouterContext): RouteDecision;