nexus-ai-pro 0.2.0

package/dist/hallucination/rag.js

@@ -0,0 +1,46 @@
+export function withRagContext(request, options) {
+    const chunks = options.chunks.slice(0, options.maxChunks || options.chunks.length);
+    const unknownAnswer = options.unknownAnswer || "I don't know based on the provided context.";
+    const citationInstruction = options.requireCitations !== false
+        ? 'Cite sources for factual claims using the chunk ids in square brackets, for example [doc-1].'
+        : 'Use only the provided context for factual claims.';
+    const context = chunks.map((chunk, index) => {
+        const id = chunk.id || `chunk-${index + 1}`;
+        const source = chunk.source ? ` source=${chunk.source}` : '';
+        return `[${id}${source}]\n${chunk.content}`;
+    }).join('\n\n');
+    const systemMessage = {
+        role: 'system',
+        content: [
+            'You are answering with Retrieval-Augmented Generation context.',
+            'Use only the provided context for factual claims.',
+            `If the answer is not present in the context, say: "${unknownAnswer}"`,
+            citationInstruction,
+            'Do not invent sources, citations, facts, numbers, names, URLs, dates, or APIs.',
+            'Context:',
+            context || '[no context provided]',
+        ].join('\n'),
+    };
+    return {
+        ...request,
+        temperature: request.temperature ?? 0,
+        topP: request.topP ?? 0.1,
+        messages: [systemMessage, ...request.messages],
+        metadata: {
+            ...request.metadata,
+            rag: {
+                chunks: chunks.map(({ id, source, score, metadata }) => ({ id, source, score, metadata })),
+                requireCitations: options.requireCitations !== false,
+            },
+        },
+    };
+}
+export function extractCitations(text) {
+    return [...new Set([...text.matchAll(/\[([^\]]+)\]/g)].map((match) => match[1]))];
+}
+export function validateCitations(responseText, chunks) {
+    const known = new Set(chunks.map((chunk) => chunk.id));
+    const citations = extractCitations(responseText);
+    const missing = citations.filter((citation) => !known.has(citation));
+    return { ok: missing.length === 0, missing };
+}

package/dist/hallucination/retrieval.d.ts

@@ -0,0 +1,24 @@
+import type { RagChunk } from './rag.js';
+export type EmbeddingProvider = (texts: string[]) => Promise<number[][]> | number[][];
+export interface VectorDocument extends RagChunk {
+    embedding?: number[];
+}
+export interface VectorSearchResult extends RagChunk {
+    score: number;
+}
+export interface VectorSearchOptions {
+    topK?: number;
+    minScore?: number;
+}
+export declare class MemoryVectorStore {
+    private documents;
+    private embed;
+    constructor(embed?: EmbeddingProvider);
+    add(documents: VectorDocument[]): Promise<void>;
+    search(query: string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    clear(): void;
+    size(): number;
+}
+export declare function createHashEmbeddings(texts: string[], dimensions?: number): number[][];
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function normalizeVector(vector: number[]): number[];

package/dist/hallucination/retrieval.js

@@ -0,0 +1,71 @@
+export class MemoryVectorStore {
+    documents = [];
+    embed;
+    constructor(embed = createHashEmbeddings) {
+        this.embed = embed;
+    }
+    async add(documents) {
+        const missing = documents.filter((doc) => !doc.embedding).map((doc) => doc.content);
+        const generated = missing.length ? await this.embed(missing) : [];
+        let generatedIndex = 0;
+        for (const doc of documents) {
+            const embedding = doc.embedding || generated[generatedIndex++];
+            this.documents.push({ ...doc, embedding: normalizeVector(embedding) });
+        }
+    }
+    async search(query, options = {}) {
+        const topK = options.topK || 5;
+        const minScore = options.minScore ?? 0;
+        const [queryEmbedding] = await this.embed([query]);
+        const normalizedQuery = normalizeVector(queryEmbedding);
+        return this.documents
+            .map(({ embedding, ...doc }) => ({
+            ...doc,
+            score: cosineSimilarity(normalizedQuery, embedding),
+        }))
+            .filter((doc) => doc.score >= minScore)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+    }
+    clear() {
+        this.documents = [];
+    }
+    size() {
+        return this.documents.length;
+    }
+}
+export function createHashEmbeddings(texts, dimensions = 384) {
+    return texts.map((text) => {
+        const vector = new Array(dimensions).fill(0);
+        const terms = text.toLowerCase().match(/[a-z0-9_'-]{2,}/g) || [];
+        for (const term of terms) {
+            const index = hashTerm(term) % dimensions;
+            vector[index] += 1;
+        }
+        return normalizeVector(vector);
+    });
+}
+export function cosineSimilarity(a, b) {
+    const length = Math.min(a.length, b.length);
+    if (length === 0)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < length; i += 1) {
+        dot += a[i] * b[i];
+    }
+    return dot;
+}
+export function normalizeVector(vector) {
+    const magnitude = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+    if (magnitude === 0)
+        return vector.map(() => 0);
+    return vector.map((value) => value / magnitude);
+}
+function hashTerm(term) {
+    let hash = 2166136261;
+    for (let i = 0; i < term.length; i += 1) {
+        hash ^= term.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}

package/dist/hallucination/verification.d.ts

@@ -0,0 +1,36 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse } from '../types/response.js';
+export interface VerificationClient {
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+}
+export interface VerificationFact {
+    text: string;
+    supported: boolean;
+    score: number;
+}
+export interface VerificationReport {
+    ok: boolean;
+    facts: VerificationFact[];
+    unsupported: VerificationFact[];
+    supportRatio: number;
+}
+export interface NliVerifier {
+    verify(claim: string, context: string): Promise<{
+        entailed: boolean;
+        score: number;
+    }>;
+}
+export interface VerificationOptions {
+    context: string[];
+    minSupportRatio?: number;
+    nli?: NliVerifier;
+    unknownAnswer?: string;
+    repair?: boolean;
+}
+export declare function completeVerified(client: VerificationClient, request: CompletionRequest, options: VerificationOptions): Promise<NexusResponse>;
+export declare function verifyAgainstContext(answer: string, options: VerificationOptions): Promise<VerificationReport>;
+export declare function extractFacts(answer: string): string[];
+export declare function lexicalEntailment(claim: string, context: string): {
+    entailed: boolean;
+    score: number;
+};

package/dist/hallucination/verification.js

@@ -0,0 +1,110 @@
+import { withFactualDefaults } from './factual.js';
+export async function completeVerified(client, request, options) {
+    const initial = await client.complete(withFactualDefaults(request, {
+        requireUnknownFallback: true,
+        unknownAnswer: options.unknownAnswer || "I don't know.",
+        chainOfThought: 'private',
+    }));
+    const report = await verifyAgainstContext(initial.content, options);
+    if (report.ok || options.repair === false) {
+        return attachVerification(initial, report);
+    }
+    const repaired = await client.complete(withFactualDefaults({
+        ...request,
+        messages: [
+            ...request.messages,
+            {
+                role: 'assistant',
+                content: initial.content,
+            },
+            {
+                role: 'user',
+                content: [
+                    'Revise the answer so every factual claim is supported by the context.',
+                    `If unsupported, answer exactly: "${options.unknownAnswer || "I don't know."}"`,
+                    'Unsupported claims:',
+                    ...report.unsupported.map((fact) => `- ${fact.text}`),
+                    'Context:',
+                    ...options.context.map((item, index) => `[context-${index + 1}] ${item}`),
+                ].join('\n'),
+            },
+        ],
+    }, {
+        requireUnknownFallback: true,
+        unknownAnswer: options.unknownAnswer || "I don't know.",
+        chainOfThought: 'private',
+    }));
+    return attachVerification(repaired, await verifyAgainstContext(repaired.content, options));
+}
+export async function verifyAgainstContext(answer, options) {
+    const context = options.context.join('\n');
+    const facts = extractFacts(answer);
+    if (facts.length === 0) {
+        return { ok: true, facts: [], unsupported: [], supportRatio: 1 };
+    }
+    const checked = await Promise.all(facts.map(async (fact) => {
+        const result = options.nli
+            ? await options.nli.verify(fact, context)
+            : lexicalEntailment(fact, context);
+        return {
+            text: fact,
+            supported: result.entailed,
+            score: result.score,
+        };
+    }));
+    const supported = checked.filter((fact) => fact.supported).length;
+    const supportRatio = supported / checked.length;
+    const minSupportRatio = options.minSupportRatio ?? 0.85;
+    const unsupported = checked.filter((fact) => !fact.supported);
+    return {
+        ok: supportRatio >= minSupportRatio && unsupported.length === 0,
+        facts: checked,
+        unsupported,
+        supportRatio,
+    };
+}
+export function extractFacts(answer) {
+    return answer
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .filter((part) => !/^(i don't know|unknown|not enough information)/i.test(part));
+}
+export function lexicalEntailment(claim, context) {
+    const claimTerms = importantTerms(claim);
+    if (claimTerms.length === 0)
+        return { entailed: true, score: 1 };
+    const contextTerms = new Set(importantTerms(context));
+    const matches = claimTerms.filter((term) => contextTerms.has(term)).length;
+    const score = matches / claimTerms.length;
+    return {
+        entailed: score >= 0.72 || context.toLowerCase().includes(claim.toLowerCase()),
+        score,
+    };
+}
+function importantTerms(text) {
+    const stop = new Set([
+        'about', 'after', 'also', 'because', 'before', 'being', 'could', 'from',
+        'have', 'into', 'only', 'over', 'than', 'that', 'their', 'there', 'these',
+        'this', 'those', 'through', 'under', 'using', 'were', 'when', 'where',
+        'which', 'while', 'with', 'would', 'your',
+    ]);
+    return (text.toLowerCase().match(/[a-z0-9_'-]{3,}/g) || [])
+        .filter((term) => !stop.has(term));
+}
+function attachVerification(response, report) {
+    return {
+        ...response,
+        meta: {
+            ...response.meta,
+            guardrailsApplied: [...response.meta.guardrailsApplied, 'chain-of-verification'],
+            verification: {
+                ok: report.ok,
+                supportRatio: report.supportRatio,
+                factsChecked: report.facts.length,
+                unsupportedFacts: report.unsupported.map((fact) => fact.text),
+            },
+        },
+        content: response.content,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+export { NexusAI } from './core/nexus.js';
+export { collectStream, mapStream, createTextStream } from './core/streaming.js';
+export { createNexusRouteHandler } from './next/route-handler.js';
+export { getModelRegistry, getModelAliases, resolveModel, resolveModelAlias, listKnownModels, listModelsForProvider, getModelCapabilities, } from './models/registry.js';
+export { MemoryCache, createCacheKey } from './cache/memory-cache.js';
+export { MemoryCacheAdapter, RedisCacheAdapter, SQLiteCacheAdapter, type CacheAdapter, type RedisLikeClient, type SQLiteLikeDatabase, } from './cache/adapters.js';
+export { SemanticCache, type SemanticCacheOptions } from './cache/semantic-cache.js';
+export { ResponseFormatError } from './core/response-format.js';
+export { hardenPrompt } from './security/prompt-hardening.js';
+export { RateLimiter, NexusRateLimitError } from './ops/rate-limiter.js';
+export { AuditLogger } from './ops/audit-logger.js';
+export { MetricsCollector, InMemoryMetrics, OpenTelemetryMetricsSink, type MetricsConfig, type MetricsSink, type OpenTelemetryLikeMeter, } from './ops/metrics.js';
+export { ProviderHealthMonitor, type HealthConfig, type ProviderHealthSnapshot, } from './ops/health.js';
+export { PipelineRunner, createPipelineContext, } from './pipeline/pipeline.js';
+export type { PipelineConfig, PipelineContext, PipelineHookName, PipelineHooksConfig, PipelineMiddleware, PipelineStep, PipelineStepName, PipelineTrace, PipelineTraceStep, } from './pipeline/types.js';
+export { withFactualDefaults, asJsonOnly, type FactualOptions, } from './hallucination/factual.js';
+export { withRagContext, extractCitations, validateCitations, type RagChunk, type RagOptions, } from './hallucination/rag.js';
+export { MemoryVectorStore, createHashEmbeddings, cosineSimilarity, type EmbeddingProvider, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, } from './hallucination/retrieval.js';
+export { withKnowledgeGraphContext, selectGraphFacts, type KnowledgeGraph, type KnowledgeGraphEdge, type KnowledgeGraphNode, type KnowledgeGraphOptions, } from './hallucination/knowledge-graph.js';
+export { completeVerified, verifyAgainstContext, extractFacts, lexicalEntailment, type NliVerifier, type VerificationClient, type VerificationFact, type VerificationOptions, type VerificationReport, } from './hallucination/verification.js';
+export { completeWithSelfConsistency, selectMostConsistent, textSimilarity, type ConsistencyClient, type SelfConsistencyOptions, } from './hallucination/consistency.js';
+export { BaseProvider, type ProviderInfo } from './providers/base.js';
+export { OpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export { OpenRouterProvider } from './providers/openrouter.js';
+export { GroqProvider } from './providers/groq.js';
+export { MistralProvider } from './providers/mistral.js';
+export { CohereProvider } from './providers/cohere.js';
+export { Router, FailoverExecutor, type RouteDecision, type RouterContext } from './router/index.js';
+export { SecurityPipeline, NexusSecurityError, SchemaValidator, InjectionDetector, PIIDetector, OutputGuard, InputGuard, SemanticInjectionClassifier, } from './security/index.js';
+export { guardrailPolicy, GUARDRAIL_POLICIES, type GuardrailPolicyName, } from './security/policies.js';
+export { SEMANTIC_INJECTION_CALIBRATION_SET, calibrateSemanticInjectionClassifier, type InjectionCalibrationExample, type InjectionCalibrationResult, } from './security/injection-calibration.js';
+export { TokenOptimizer, PromptDensifier, BudgetEnforcer, TokenBudgetError, } from './optimizer/index.js';
+export { estimateCost, assertWithinCostBudget, CostBudgetError, type CostEstimateInput, } from './optimizer/cost.js';
+export { createOpenAIEmbeddingProvider, createGeminiEmbeddingProvider, createCohereEmbeddingProvider, type OpenAIEmbeddingOptions, type GeminiEmbeddingOptions, type CohereEmbeddingOptions, } from './embeddings/providers.js';
+export { tool, ToolExecutor } from './agent/tool.js';
+export { AgentLoop, type AgentModelClient } from './agent/loop.js';
+export { Tokenizer } from './utils/tokenizer.js';
+export { ingestDocuments, ingestText, type DocumentSource, type IngestionOptions, type IngestionResult, } from './rag/ingestion.js';
+export { ingestFilesAfterScan, createPdfExtractor, createOcrExtractor, type FileTextExtractor, type FileIngestionOptions, type FileIngestionResult, } from './rag/file-ingestion.js';
+export { UploadScanner, scanUploads, type FileUpload, type UploadScannerOptions, type UploadScanFinding, type UploadScanResult, } from './security/upload-scanner.js';
+export { EvalRunner, type EvalCase, type EvalClient, type EvalResult, type EvalRunResult, } from './evals/runner.js';
+export { calculateEvalMetrics, exactMatch, f1Score, semanticSimilarity, passAtK, perplexity, tokensPerSecond, faithfulness, contextualPrecision, contextualRecall, toxicityScore, biasScore, policyAdherence, refusalRate, type EvalMetrics, type MetricInputs, type QualityMetrics, type OperationalMetrics, type RagMetrics, type SafetyMetrics, } from './evals/metrics.js';
+export { summarizeVerifyFormat, ragAnswer, extractStructured, classifyRoute, compareAndDecide, type SummarizeVerifyFormatOptions, type RagAnswerOptions, type ExtractStructuredOptions, type ClassifyRouteOptions, type CompareOptions, type WorkflowClient, type WorkflowResult, type WorkflowStepResult, } from './workflow/chains.js';
+export { supportTriageWorkflow, salesQualificationWorkflow, legalReviewWorkflow, codeReviewWorkflow, type DomainWorkflowOptions, type SupportWorkflowOptions, type SalesWorkflowOptions, type LegalReviewWorkflowOptions, type CodeReviewWorkflowOptions, } from './workflow/domain.js';
+export { runBatch, type BatchOptions, type BatchItemResult, } from './jobs/batch.js';
+export { JobQueue, type QueueJob, type QueueOptions, } from './jobs/queue.js';
+export { RedisQueueAdapter, BullMQQueueAdapter, type DurableQueueAdapter, type RedisQueueLikeClient, type BullMQLikeQueue, } from './jobs/durable-adapters.js';
+export { createFetchUrlTool, createSearchTool, type WebConnectorOptions, } from './connectors/web.js';
+export { PROVIDER_CONFORMANCE_FIXTURES, runProviderConformance, type ProviderConformanceCase, type ProviderConformanceResult, } from './testing/provider-conformance.js';
+export { OpenTelemetryTraceExporter, type OpenTelemetryLikeSpan, type OpenTelemetryLikeTracer, } from './ops/otel-tracing.js';
+export type { CompletionRequest, Message, MessageRole, ContentPart, TextContent, ImageContent, AudioContent, VideoContent, ToolDefinition, ToolCallResult, } from './types/messages.js';
+export type { CostEstimate, NexusPlan, } from './types/planning.js';
+export type { NexusResponse, NexusStream, ResponseMeta, StreamChunk, ToolCall, } from './types/response.js';
+export type { NexusAIConfig, ProvidersConfig, OpenAIProviderConfig, AnthropicProviderConfig, GoogleProviderConfig, OllamaProviderConfig, GroqProviderConfig, MistralProviderConfig, CohereProviderConfig, CustomProviderConfig, RoutingConfig, RoutingRule, RoutingStrategy, FallbackConfig, ResponseFormatConfig, RetryConfig, CostBudgetConfig, AuditLogConfig, RateLimitConfig, } from './types/config.js';
+export type { Modality, ModelCapabilities, ModelEndpoint, ModelStatus, ProviderCapabilities, ReasoningEffort, RoutingModelPreference, } from './types/providers.js';
+export { KNOWN_MODELS, resolveProvider } from './types/providers.js';
+export type { SecurityLevel, SecurityAction, PIIType, InjectionDetectionConfig, PIIConfig, SecurityConfig, SecurityFinding, SecurityResult, } from './types/security.js';
+export type { BudgetExceededAction, DensificationConfig, BudgetConfig, TokenOptimizerConfig, TokenUsageSnapshot, OptimizationResult, } from './types/optimizer.js';
+export type { AgentStep, AgentConfig, AgentResult, ToolExecutionResult, } from './types/agent.js';

package/dist/index.js

@@ -0,0 +1,53 @@
+export { NexusAI } from './core/nexus.js';
+export { collectStream, mapStream, createTextStream } from './core/streaming.js';
+export { createNexusRouteHandler } from './next/route-handler.js';
+export { getModelRegistry, getModelAliases, resolveModel, resolveModelAlias, listKnownModels, listModelsForProvider, getModelCapabilities, } from './models/registry.js';
+export { MemoryCache, createCacheKey } from './cache/memory-cache.js';
+export { MemoryCacheAdapter, RedisCacheAdapter, SQLiteCacheAdapter, } from './cache/adapters.js';
+export { SemanticCache } from './cache/semantic-cache.js';
+export { ResponseFormatError } from './core/response-format.js';
+export { hardenPrompt } from './security/prompt-hardening.js';
+export { RateLimiter, NexusRateLimitError } from './ops/rate-limiter.js';
+export { AuditLogger } from './ops/audit-logger.js';
+export { MetricsCollector, InMemoryMetrics, OpenTelemetryMetricsSink, } from './ops/metrics.js';
+export { ProviderHealthMonitor, } from './ops/health.js';
+export { PipelineRunner, createPipelineContext, } from './pipeline/pipeline.js';
+export { withFactualDefaults, asJsonOnly, } from './hallucination/factual.js';
+export { withRagContext, extractCitations, validateCitations, } from './hallucination/rag.js';
+export { MemoryVectorStore, createHashEmbeddings, cosineSimilarity, } from './hallucination/retrieval.js';
+export { withKnowledgeGraphContext, selectGraphFacts, } from './hallucination/knowledge-graph.js';
+export { completeVerified, verifyAgainstContext, extractFacts, lexicalEntailment, } from './hallucination/verification.js';
+export { completeWithSelfConsistency, selectMostConsistent, textSimilarity, } from './hallucination/consistency.js';
+export { BaseProvider } from './providers/base.js';
+export { OpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider } from './providers/anthropic.js';
+export { GoogleProvider } from './providers/google.js';
+export { OllamaProvider } from './providers/ollama.js';
+export { OpenRouterProvider } from './providers/openrouter.js';
+export { GroqProvider } from './providers/groq.js';
+export { MistralProvider } from './providers/mistral.js';
+export { CohereProvider } from './providers/cohere.js';
+export { Router, FailoverExecutor } from './router/index.js';
+export { SecurityPipeline, NexusSecurityError, SchemaValidator, InjectionDetector, PIIDetector, OutputGuard, InputGuard, SemanticInjectionClassifier, } from './security/index.js';
+export { guardrailPolicy, GUARDRAIL_POLICIES, } from './security/policies.js';
+export { SEMANTIC_INJECTION_CALIBRATION_SET, calibrateSemanticInjectionClassifier, } from './security/injection-calibration.js';
+export { TokenOptimizer, PromptDensifier, BudgetEnforcer, TokenBudgetError, } from './optimizer/index.js';
+export { estimateCost, assertWithinCostBudget, CostBudgetError, } from './optimizer/cost.js';
+export { createOpenAIEmbeddingProvider, createGeminiEmbeddingProvider, createCohereEmbeddingProvider, } from './embeddings/providers.js';
+export { tool, ToolExecutor } from './agent/tool.js';
+export { AgentLoop } from './agent/loop.js';
+export { Tokenizer } from './utils/tokenizer.js';
+export { ingestDocuments, ingestText, } from './rag/ingestion.js';
+export { ingestFilesAfterScan, createPdfExtractor, createOcrExtractor, } from './rag/file-ingestion.js';
+export { UploadScanner, scanUploads, } from './security/upload-scanner.js';
+export { EvalRunner, } from './evals/runner.js';
+export { calculateEvalMetrics, exactMatch, f1Score, semanticSimilarity, passAtK, perplexity, tokensPerSecond, faithfulness, contextualPrecision, contextualRecall, toxicityScore, biasScore, policyAdherence, refusalRate, } from './evals/metrics.js';
+export { summarizeVerifyFormat, ragAnswer, extractStructured, classifyRoute, compareAndDecide, } from './workflow/chains.js';
+export { supportTriageWorkflow, salesQualificationWorkflow, legalReviewWorkflow, codeReviewWorkflow, } from './workflow/domain.js';
+export { runBatch, } from './jobs/batch.js';
+export { JobQueue, } from './jobs/queue.js';
+export { RedisQueueAdapter, BullMQQueueAdapter, } from './jobs/durable-adapters.js';
+export { createFetchUrlTool, createSearchTool, } from './connectors/web.js';
+export { PROVIDER_CONFORMANCE_FIXTURES, runProviderConformance, } from './testing/provider-conformance.js';
+export { OpenTelemetryTraceExporter, } from './ops/otel-tracing.js';
+export { KNOWN_MODELS, resolveProvider } from './types/providers.js';

package/dist/jobs/batch.d.ts

@@ -0,0 +1,11 @@
+export interface BatchOptions {
+    concurrency?: number;
+    stopOnError?: boolean;
+}
+export interface BatchItemResult<T> {
+    index: number;
+    ok: boolean;
+    value?: T;
+    error?: string;
+}
+export declare function runBatch<TInput, TOutput>(items: TInput[], worker: (item: TInput, index: number) => Promise<TOutput>, options?: BatchOptions): Promise<Array<BatchItemResult<TOutput>>>;

package/dist/jobs/batch.js

@@ -0,0 +1,32 @@
+export async function runBatch(items, worker, options = {}) {
+    const concurrency = Math.max(1, options.concurrency || 3);
+    const results = [];
+    let nextIndex = 0;
+    let stopped = false;
+    async function runNext() {
+        if (stopped)
+            return;
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= items.length)
+            return;
+        try {
+            const value = await worker(items[index], index);
+            results[index] = { index, ok: true, value };
+        }
+        catch (error) {
+            results[index] = {
+                index,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+            if (options.stopOnError) {
+                stopped = true;
+                return;
+            }
+        }
+        await runNext();
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => runNext()));
+    return results.filter(Boolean);
+}

package/dist/jobs/durable-adapters.d.ts

@@ -0,0 +1,48 @@
+import type { QueueJob } from './queue.js';
+export interface DurableQueueAdapter<TPayload = unknown> {
+    enqueue(queueName: string, job: QueueJob<TPayload>): Promise<void> | void;
+    get(queueName: string, id: string): Promise<QueueJob<TPayload> | undefined> | QueueJob<TPayload> | undefined;
+    update(queueName: string, job: QueueJob<TPayload>): Promise<void> | void;
+    list(queueName: string): Promise<Array<QueueJob<TPayload>>> | Array<QueueJob<TPayload>>;
+}
+export interface RedisQueueLikeClient {
+    lpush(key: string, value: string): Promise<unknown> | unknown;
+    hset(key: string, field: string, value: string): Promise<unknown> | unknown;
+    hget(key: string, field: string): Promise<string | null> | string | null;
+    hvals(key: string): Promise<string[]> | string[];
+}
+export declare class RedisQueueAdapter<TPayload = unknown> implements DurableQueueAdapter<TPayload> {
+    private client;
+    private prefix;
+    constructor(client: RedisQueueLikeClient, prefix?: string);
+    enqueue(queueName: string, job: QueueJob<TPayload>): Promise<void>;
+    get(queueName: string, id: string): Promise<QueueJob<TPayload> | undefined>;
+    update(queueName: string, job: QueueJob<TPayload>): Promise<void>;
+    list(queueName: string): Promise<Array<QueueJob<TPayload>>>;
+    private jobsKey;
+    private pendingKey;
+}
+export interface BullMQLikeQueue<TPayload = unknown> {
+    add(name: string, data: TPayload, options?: Record<string, unknown>): Promise<{
+        id?: string | number;
+    }> | {
+        id?: string | number;
+    };
+    getJob(id: string): Promise<{
+        id: string | number;
+        data: TPayload;
+        returnvalue?: unknown;
+        failedReason?: string;
+    } | null>;
+}
+export declare class BullMQQueueAdapter<TPayload = unknown> {
+    private queue;
+    constructor(queue: BullMQLikeQueue<TPayload>);
+    enqueue(name: string, payload: TPayload, options?: Record<string, unknown>): Promise<string>;
+    get(id: string): Promise<{
+        id: string;
+        payload: TPayload;
+        result?: unknown;
+        error?: string;
+    } | undefined>;
+}

package/dist/jobs/durable-adapters.js

@@ -0,0 +1,50 @@
+export class RedisQueueAdapter {
+    client;
+    prefix;
+    constructor(client, prefix = 'nexus-ai-pro:queue:') {
+        this.client = client;
+        this.prefix = prefix;
+    }
+    async enqueue(queueName, job) {
+        await this.client.hset(this.jobsKey(queueName), job.id, JSON.stringify(job));
+        await this.client.lpush(this.pendingKey(queueName), job.id);
+    }
+    async get(queueName, id) {
+        const raw = await this.client.hget(this.jobsKey(queueName), id);
+        return raw ? JSON.parse(raw) : undefined;
+    }
+    async update(queueName, job) {
+        await this.client.hset(this.jobsKey(queueName), job.id, JSON.stringify(job));
+    }
+    async list(queueName) {
+        const values = await this.client.hvals(this.jobsKey(queueName));
+        return values.map((value) => JSON.parse(value));
+    }
+    jobsKey(queueName) {
+        return `${this.prefix}${queueName}:jobs`;
+    }
+    pendingKey(queueName) {
+        return `${this.prefix}${queueName}:pending`;
+    }
+}
+export class BullMQQueueAdapter {
+    queue;
+    constructor(queue) {
+        this.queue = queue;
+    }
+    async enqueue(name, payload, options = {}) {
+        const job = await this.queue.add(name, payload, options);
+        return String(job.id || '');
+    }
+    async get(id) {
+        const job = await this.queue.getJob(id);
+        if (!job)
+            return undefined;
+        return {
+            id: String(job.id),
+            payload: job.data,
+            result: job.returnvalue,
+            error: job.failedReason,
+        };
+    }
+}

package/dist/jobs/queue.d.ts

@@ -0,0 +1,24 @@
+export interface QueueJob<T = unknown> {
+    id: string;
+    payload: T;
+    attempts: number;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    result?: unknown;
+    error?: string;
+}
+export interface QueueOptions {
+    concurrency?: number;
+    maxAttempts?: number;
+}
+export declare class JobQueue<TPayload = unknown, TResult = unknown> {
+    private worker;
+    private options;
+    private jobs;
+    private running;
+    constructor(worker: (payload: TPayload, job: QueueJob<TPayload>) => Promise<TResult>, options?: QueueOptions);
+    enqueue(payload: TPayload, id?: string): QueueJob<TPayload>;
+    list(): Array<QueueJob<TPayload>>;
+    get(id: string): QueueJob<TPayload> | undefined;
+    private drain;
+    private run;
+}

package/dist/jobs/queue.js

@@ -0,0 +1,57 @@
+export class JobQueue {
+    worker;
+    options;
+    jobs = [];
+    running = 0;
+    constructor(worker, options = {}) {
+        this.worker = worker;
+        this.options = options;
+    }
+    enqueue(payload, id = `job-${Date.now()}-${Math.random().toString(16).slice(2)}`) {
+        const job = {
+            id,
+            payload,
+            attempts: 0,
+            status: 'queued',
+        };
+        this.jobs.push(job);
+        void this.drain();
+        return job;
+    }
+    list() {
+        return [...this.jobs];
+    }
+    get(id) {
+        return this.jobs.find((job) => job.id === id);
+    }
+    async drain() {
+        const concurrency = this.options.concurrency || 1;
+        while (this.running < concurrency) {
+            const job = this.jobs.find((item) => item.status === 'queued');
+            if (!job)
+                return;
+            this.running += 1;
+            void this.run(job).finally(() => {
+                this.running -= 1;
+                void this.drain();
+            });
+        }
+    }
+    async run(job) {
+        job.status = 'running';
+        job.attempts += 1;
+        try {
+            job.result = await this.worker(job.payload, job);
+            job.status = 'completed';
+        }
+        catch (error) {
+            job.error = error instanceof Error ? error.message : String(error);
+            if (job.attempts < (this.options.maxAttempts || 1)) {
+                job.status = 'queued';
+            }
+            else {
+                job.status = 'failed';
+            }
+        }
+    }
+}

package/dist/models/registry.d.ts

@@ -0,0 +1,15 @@
+import type { NexusAIConfig } from '../types/config.js';
+import { type ModelCapabilities } from '../types/providers.js';
+export interface ResolvedModel {
+    requestedModel: string;
+    model: string;
+    providerName: string | null;
+    capabilities?: ModelCapabilities;
+}
+export declare function resolveModelAlias(model: string, aliases?: Record<string, string>): string;
+export declare function getModelRegistry(config?: Pick<NexusAIConfig, 'models'>): Record<string, ModelCapabilities>;
+export declare function getModelAliases(config?: Pick<NexusAIConfig, 'models'>): Record<string, string>;
+export declare function resolveModel(model: string, config?: Pick<NexusAIConfig, 'models'>): ResolvedModel;
+export declare function listKnownModels(config?: Pick<NexusAIConfig, 'models'>): string[];
+export declare function listModelsForProvider(providerName: string, config?: Pick<NexusAIConfig, 'models'>): string[];
+export declare function getModelCapabilities(model: string, config?: Pick<NexusAIConfig, 'models'>): ModelCapabilities | undefined;