nexus-ai-pro 0.2.0

package/dist/optimizer/densifier.js

@@ -0,0 +1,77 @@
+export class PromptDensifier {
+    densifyRequest(request, config = {}) {
+        if (config.enabled === false)
+            return { request, techniques: [] };
+        const techniques = config.techniques || ['whitespace-cleanup', 'phrase-compression', 'list-compaction'];
+        const applied = new Set();
+        const next = {
+            ...request,
+            messages: request.messages.map((message) => ({
+                ...message,
+                content: typeof message.content === 'string'
+                    ? this.densifyText(message.content, techniques, applied, config)
+                    : message.content.map((part) => part.type === 'text'
+                        ? { ...part, text: this.densifyText(part.text, techniques, applied, config) }
+                        : part),
+            })),
+        };
+        return { request: next, techniques: [...applied] };
+    }
+    densifyText(text, techniques, applied, config) {
+        const segments = this.splitCodeBlocks(text, config.preserveCodeBlocks !== false);
+        return segments.map((segment) => {
+            if (segment.type === 'code')
+                return segment.value;
+            let output = segment.value;
+            if (techniques.includes('whitespace-cleanup')) {
+                const before = output;
+                output = output
+                    .replace(/[ \t]+/g, ' ')
+                    .replace(/\n{3,}/g, '\n\n')
+                    .replace(/[ \t]+\n/g, '\n')
+                    .trim();
+                if (output !== before)
+                    applied.add('whitespace-cleanup');
+            }
+            if (techniques.includes('phrase-compression')) {
+                const before = output;
+                output = output
+                    .replace(/please make sure that/gi, 'ensure')
+                    .replace(/you should/gi, 'do')
+                    .replace(/it is important to/gi, 'must')
+                    .replace(/in order to/gi, 'to')
+                    .replace(/due to the fact that/gi, 'because')
+                    .replace(/at this point in time/gi, 'now')
+                    .replace(/as soon as possible/gi, 'ASAP');
+                if (output !== before)
+                    applied.add('phrase-compression');
+            }
+            if (techniques.includes('list-compaction')) {
+                const before = output;
+                output = output.replace(/\n\s*[-*]\s+/g, '\n- ');
+                if (output !== before)
+                    applied.add('list-compaction');
+            }
+            return output;
+        }).join('');
+    }
+    splitCodeBlocks(text, preserveCodeBlocks) {
+        if (!preserveCodeBlocks)
+            return [{ type: 'text', value: text }];
+        const parts = [];
+        const regex = /```[\s\S]*?```/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            if (match.index > lastIndex) {
+                parts.push({ type: 'text', value: text.slice(lastIndex, match.index) });
+            }
+            parts.push({ type: 'code', value: match[0] });
+            lastIndex = match.index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+            parts.push({ type: 'text', value: text.slice(lastIndex) });
+        }
+        return parts;
+    }
+}

package/dist/optimizer/index.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { OptimizationResult, TokenOptimizerConfig } from '../types/optimizer.js';
+export declare class TokenOptimizer {
+    private config;
+    private tokenizer;
+    private densifier;
+    private budget;
+    constructor(config?: TokenOptimizerConfig);
+    optimize(request: CompletionRequest): OptimizationResult<CompletionRequest>;
+}
+export { PromptDensifier } from './densifier.js';
+export { BudgetEnforcer, TokenBudgetError } from './budget.js';

package/dist/optimizer/index.js

@@ -0,0 +1,59 @@
+import { Tokenizer } from '../utils/tokenizer.js';
+import { PromptDensifier } from './densifier.js';
+import { BudgetEnforcer } from './budget.js';
+export class TokenOptimizer {
+    config;
+    tokenizer = new Tokenizer();
+    densifier = new PromptDensifier();
+    budget = new BudgetEnforcer(this.tokenizer);
+    constructor(config = {}) {
+        this.config = config;
+    }
+    optimize(request) {
+        if (this.config.enabled === false) {
+            return {
+                value: request,
+                usage: {
+                    beforeTokens: 0,
+                    afterTokens: 0,
+                    savedTokens: 0,
+                    savedPercent: 0,
+                },
+                techniquesApplied: [],
+                warnings: [],
+            };
+        }
+        const beforeTokens = this.tokenizer.estimateRequestTokens(request);
+        let value = request;
+        const techniquesApplied = [];
+        const warnings = [];
+        const budgetConfig = this.config.budget || {};
+        const preBudget = this.budget.check(value, budgetConfig);
+        warnings.push(...preBudget.warnings);
+        const shouldDensify = this.config.densification?.enabled !== false && (this.config.densification?.enabled === true ||
+            budgetConfig.onExceeded === 'densify' ||
+            preBudget.exceeded);
+        if (shouldDensify) {
+            const densified = this.densifier.densifyRequest(value, this.config.densification);
+            value = densified.request;
+            techniquesApplied.push(...densified.techniques);
+        }
+        value = this.budget.enforce(value, budgetConfig);
+        const afterTokens = this.tokenizer.estimateRequestTokens(value);
+        const savedTokens = Math.max(0, beforeTokens - afterTokens);
+        const savedPercent = beforeTokens === 0 ? 0 : Math.round((savedTokens / beforeTokens) * 10000) / 100;
+        return {
+            value,
+            usage: {
+                beforeTokens,
+                afterTokens,
+                savedTokens,
+                savedPercent,
+            },
+            techniquesApplied: [...new Set(techniquesApplied)],
+            warnings,
+        };
+    }
+}
+export { PromptDensifier } from './densifier.js';
+export { BudgetEnforcer, TokenBudgetError } from './budget.js';

package/dist/pipeline/pipeline.d.ts

@@ -0,0 +1,14 @@
+import type { PipelineConfig, PipelineContext, PipelineHookName, PipelineStep, PipelineStepName } from './types.js';
+export declare class PipelineRunner {
+    private config;
+    private steps;
+    constructor(config?: PipelineConfig);
+    use(step: PipelineStep): this;
+    runHook(name: PipelineHookName, context: PipelineContext): Promise<PipelineContext>;
+    runCustomSteps(context: PipelineContext): Promise<PipelineContext>;
+    trace<T>(context: PipelineContext, name: PipelineStepName, fn: () => T | Promise<T>, metadata?: Record<string, unknown>): Promise<T>;
+    finish(context: PipelineContext): PipelineContext;
+    private runMiddleware;
+    private handlersForHook;
+}
+export declare function createPipelineContext(request: import('../types/messages.js').CompletionRequest): PipelineContext;

package/dist/pipeline/pipeline.js

@@ -0,0 +1,106 @@
+export class PipelineRunner {
+    config;
+    steps = [];
+    constructor(config = {}) {
+        this.config = config;
+        for (const step of config.steps || []) {
+            this.use(step);
+        }
+    }
+    use(step) {
+        this.steps.push(step);
+        return this;
+    }
+    async runHook(name, context) {
+        if (this.config.enabled === false)
+            return context;
+        const handlers = this.handlersForHook(name);
+        let next = context;
+        for (const handler of handlers) {
+            next = await this.runMiddleware(name, handler, next);
+        }
+        return next;
+    }
+    async runCustomSteps(context) {
+        if (this.config.enabled === false)
+            return context;
+        let next = context;
+        for (const step of this.steps) {
+            next = await this.runMiddleware(step.name, step.run, next);
+        }
+        return next;
+    }
+    async trace(context, name, fn, metadata) {
+        if (this.config.trace === false) {
+            return await fn();
+        }
+        const started = Date.now();
+        const startedAt = new Date(started).toISOString();
+        try {
+            const result = await fn();
+            const ended = Date.now();
+            context.trace.steps.push({
+                name,
+                startedAt,
+                endedAt: new Date(ended).toISOString(),
+                durationMs: ended - started,
+                ok: true,
+                metadata,
+            });
+            return result;
+        }
+        catch (error) {
+            const ended = Date.now();
+            context.trace.steps.push({
+                name,
+                startedAt,
+                endedAt: new Date(ended).toISOString(),
+                durationMs: ended - started,
+                ok: false,
+                metadata,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    finish(context) {
+        const ended = Date.now();
+        context.trace.endedAt = new Date(ended).toISOString();
+        context.trace.durationMs = ended - Date.parse(context.trace.startedAt);
+        return context;
+    }
+    async runMiddleware(name, handler, context) {
+        return this.trace(context, name, async () => {
+            const result = await handler(context);
+            if (!result)
+                return context;
+            if ('messages' in result && 'model' in result) {
+                context.request = result;
+                return context;
+            }
+            if ('content' in result && 'role' in result && 'meta' in result) {
+                context.response = result;
+                return context;
+            }
+            return result;
+        });
+    }
+    handlersForHook(name) {
+        const hook = this.config.hooks?.[name];
+        if (!hook)
+            return [];
+        return Array.isArray(hook) ? hook : [hook];
+    }
+}
+export function createPipelineContext(request) {
+    return {
+        request,
+        securityFindings: [],
+        guardrailsApplied: [],
+        metadata: {},
+        trace: {
+            startedAt: new Date().toISOString(),
+            steps: [],
+        },
+    };
+}

package/dist/pipeline/types.d.ts

@@ -0,0 +1,46 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse } from '../types/response.js';
+import type { RouteDecision } from '../router/types.js';
+import type { OptimizationResult } from '../types/optimizer.js';
+import type { SecurityFinding } from '../types/security.js';
+export type PipelineHookName = 'beforeInput' | 'afterSecurity' | 'beforeProvider' | 'afterProvider' | 'beforeReturn';
+export type PipelineStepName = PipelineHookName | 'responseFormat' | 'tokenOptimization' | 'inputSecurity' | 'routing' | 'costBudget' | 'cacheLookup' | 'providerCall' | 'outputSecurity' | 'responseValidation' | 'cacheWrite' | 'auditLog' | string;
+export interface PipelineTraceStep {
+    name: PipelineStepName;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    ok: boolean;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+export interface PipelineTrace {
+    requestId?: string;
+    startedAt: string;
+    endedAt?: string;
+    durationMs?: number;
+    steps: PipelineTraceStep[];
+}
+export interface PipelineContext {
+    request: CompletionRequest;
+    response?: NexusResponse;
+    route?: RouteDecision;
+    optimization?: OptimizationResult<CompletionRequest>;
+    securityFindings: SecurityFinding[];
+    guardrailsApplied: string[];
+    metadata: Record<string, unknown>;
+    trace: PipelineTrace;
+}
+export type PipelineMiddleware = (context: PipelineContext) => void | PipelineContext | CompletionRequest | NexusResponse | Promise<void | PipelineContext | CompletionRequest | NexusResponse>;
+export interface PipelineStep {
+    name: PipelineStepName;
+    run: PipelineMiddleware;
+}
+export type PipelineHooksConfig = Partial<Record<PipelineHookName, PipelineMiddleware | PipelineMiddleware[]>>;
+export interface PipelineConfig {
+    enabled?: boolean;
+    trace?: boolean;
+    includeTraceInResponse?: boolean;
+    hooks?: PipelineHooksConfig;
+    steps?: PipelineStep[];
+}

package/dist/pipeline/types.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/anthropic.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 { AnthropicProviderConfig } from '../types/config.js';
+export declare class AnthropicProvider extends BaseProvider {
+    readonly info: ProviderInfo;
+    private client;
+    private config;
+    constructor(config: AnthropicProviderConfig);
+    private getClient;
+    private formatMessages;
+    private formatToolsAnthropic;
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,183 @@
+import { BaseProvider } from './base.js';
+import { generateRequestId } from '../utils/ids.js';
+export class AnthropicProvider extends BaseProvider {
+    info = { name: 'anthropic', isLocal: false };
+    client;
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async getClient() {
+        if (!this.client) {
+            const { default: Anthropic } = await import('@anthropic-ai/sdk');
+            this.client = new Anthropic({
+                apiKey: this.config.apiKey,
+                baseURL: this.config.baseUrl,
+            });
+        }
+        return this.client;
+    }
+    formatMessages(messages) {
+        let system;
+        const formatted = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                system = typeof msg.content === 'string'
+                    ? msg.content
+                    : msg.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n');
+                continue;
+            }
+            if (typeof msg.content === 'string') {
+                formatted.push({ role: msg.role === 'assistant' ? 'assistant' : 'user', content: msg.content });
+                continue;
+            }
+            const parts = msg.content.map((part) => {
+                switch (part.type) {
+                    case 'text':
+                        return { type: 'text', text: part.text };
+                    case 'image': {
+                        const src = part.source;
+                        if ('base64' in src) {
+                            return {
+                                type: 'image',
+                                source: { type: 'base64', media_type: src.mimeType || 'image/png', data: src.base64 },
+                            };
+                        }
+                        if ('buffer' in src) {
+                            return {
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: src.mimeType || 'image/png',
+                                    data: src.buffer.toString('base64'),
+                                },
+                            };
+                        }
+                        if ('url' in src) {
+                            return { type: 'image', source: { type: 'url', url: src.url } };
+                        }
+                        return { type: 'text', text: '[image from path — requires preprocessing]' };
+                    }
+                    default:
+                        return { type: 'text', text: `[${part.type} content — not yet supported for this provider]` };
+                }
+            });
+            formatted.push({ role: msg.role === 'assistant' ? 'assistant' : 'user', content: parts });
+        }
+        return { system, messages: formatted };
+    }
+    formatToolsAnthropic(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.parameters,
+        }));
+    }
+    async complete(request) {
+        const client = await this.getClient();
+        const startTime = Date.now();
+        const { system, messages } = this.formatMessages(request.messages);
+        const params = {
+            model: request.model,
+            messages,
+            max_tokens: request.maxTokens || 4096,
+            temperature: request.temperature,
+            top_p: request.topP,
+            stop_sequences: request.stop ? (Array.isArray(request.stop) ? request.stop : [request.stop]) : undefined,
+        };
+        if (system)
+            params.system = system;
+        const tools = this.formatToolsAnthropic(request.tools);
+        if (tools)
+            params.tools = tools;
+        const result = await client.messages.create(params);
+        const latency = Date.now() - startTime;
+        let content = '';
+        const toolCalls = [];
+        for (const block of result.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: { name: block.name, arguments: JSON.stringify(block.input) },
+                });
+            }
+        }
+        return {
+            content,
+            role: 'assistant',
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            finishReason: result.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: 'anthropic',
+                modelUsed: result.model,
+                latencyMs: latency,
+                tokensInput: result.usage?.input_tokens || 0,
+                tokensOutput: result.usage?.output_tokens || 0,
+                tokensSaved: 0,
+                estimatedCost: `$${((result.usage?.input_tokens || 0) / 1000 * 0.003 + (result.usage?.output_tokens || 0) / 1000 * 0.015).toFixed(4)}`,
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    stream(request) {
+        const self = this;
+        return this.createStream(async function* () {
+            const client = await self.getClient();
+            const startTime = Date.now();
+            const { system, messages } = self.formatMessages(request.messages);
+            const params = {
+                model: request.model,
+                messages,
+                max_tokens: request.maxTokens || 4096,
+                temperature: request.temperature,
+                top_p: request.topP,
+                stream: true,
+            };
+            if (system)
+                params.system = system;
+            const tools = self.formatToolsAnthropic(request.tools);
+            if (tools)
+                params.tools = tools;
+            const stream = client.messages.stream(params);
+            for await (const event of stream) {
+                if (event.type === 'content_block_delta') {
+                    if (event.delta.type === 'text_delta') {
+                        yield { type: 'text', content: event.delta.text };
+                    }
+                    else if (event.delta.type === 'input_json_delta') {
+                        // Tool call argument streaming — buffered by Anthropic SDK
+                    }
+                }
+                if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                    // Tool call started
+                }
+                if (event.type === 'message_stop') {
+                    yield {
+                        type: 'done',
+                        meta: {
+                            requestId: generateRequestId(),
+                            providerUsed: 'anthropic',
+                            modelUsed: request.model,
+                            latencyMs: Date.now() - startTime,
+                            tokensInput: 0,
+                            tokensOutput: 0,
+                            tokensSaved: 0,
+                            estimatedCost: '$0.00',
+                            cacheHit: false,
+                            guardrailsApplied: [],
+                        },
+                    };
+                }
+            }
+        });
+    }
+}

package/dist/providers/base.d.ts

@@ -0,0 +1,19 @@
+import type { CompletionRequest, Message, ToolDefinition } from '../types/messages.js';
+import type { NexusResponse, NexusStream, StreamChunk } from '../types/response.js';
+export interface ProviderInfo {
+    name: string;
+    isLocal: boolean;
+}
+export declare abstract class BaseProvider {
+    abstract readonly info: ProviderInfo;
+    abstract complete(request: CompletionRequest): Promise<NexusResponse>;
+    abstract stream(request: CompletionRequest): NexusStream;
+    healthCheck(): Promise<boolean>;
+    protected createBaseResponse(provider: string, model: string): NexusResponse;
+    protected extractTextContent(messages: Message[]): Array<{
+        role: string;
+        content: string;
+    }>;
+    protected formatTools(tools?: ToolDefinition[]): unknown[] | undefined;
+    protected createStream(generator: () => AsyncGenerator<StreamChunk>): NexusStream;
+}

package/dist/providers/base.js

@@ -0,0 +1,75 @@
+import { generateRequestId } from '../utils/ids.js';
+export class BaseProvider {
+    async healthCheck() {
+        return true;
+    }
+    createBaseResponse(provider, model) {
+        return {
+            content: '',
+            role: 'assistant',
+            finishReason: 'stop',
+            meta: {
+                requestId: generateRequestId(),
+                providerUsed: provider,
+                modelUsed: model,
+                latencyMs: 0,
+                tokensInput: 0,
+                tokensOutput: 0,
+                tokensSaved: 0,
+                estimatedCost: '$0.00',
+                cacheHit: false,
+                guardrailsApplied: [],
+            },
+        };
+    }
+    extractTextContent(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'),
+        }));
+    }
+    formatTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return tools.map((t) => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+    createStream(generator) {
+        let aborted = false;
+        const stream = {
+            [Symbol.asyncIterator]() {
+                const gen = generator();
+                return {
+                    async next() {
+                        if (aborted)
+                            return { done: true, value: undefined };
+                        return gen.next();
+                    },
+                    async return() {
+                        aborted = true;
+                        return { done: true, value: undefined };
+                    },
+                    async throw(e) {
+                        aborted = true;
+                        return gen.throw(e);
+                    },
+                };
+            },
+            abort() {
+                aborted = true;
+            },
+        };
+        return stream;
+    }
+}

package/dist/providers/cohere.d.ts

@@ -0,0 +1,16 @@
+import { BaseProvider, type ProviderInfo } from './base.js';
+import type { CohereProviderConfig } from '../types/config.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+export declare class CohereProvider extends BaseProvider {
+    readonly info: ProviderInfo;
+    private config;
+    constructor(config: CohereProviderConfig);
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    stream(request: CompletionRequest): NexusStream;
+    healthCheck(): Promise<boolean>;
+    private baseUrl;
+    private stripPrefix;
+    private extractResponseText;
+    private estimateCost;
+}