nexus-ai-pro 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@ Notable changes to this project are recorded here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+### Added
+
+- SMS routing on `updatePhoneNumber`. `UpdatePhoneNumberRequest` now carries `smsUrl`, `smsMethod`,
+  `smsFallbackUrl`, and `smsFallbackMethod`, and the Twilio provider maps them to `SmsUrl`,
+  `SmsMethod`, `SmsFallbackUrl`, and `SmsFallbackMethod`. Only the voice leg could be repointed
+  before, so an application holding SMS-enabled numbers had to drop to the provider SDK to say where
+  inbound messages should be delivered.
+- `TelephonyPhoneNumber` reports the number's current `smsUrl`, `smsMethod`, `smsFallbackUrl`, and
+  `smsFallbackMethod`, so message routing can be verified the same way voice routing already is.
+
+## [1.2.1] - 2026-08-10
+
+### Fixed
+
+- TypeScript consumers of the CommonJS build no longer resolve ESM declarations. The CommonJS build
+  now emits its own `.d.ts` files, and each export subpath carries per-condition types, so `require()`
+  resolves CommonJS declarations instead of reporting TS1479 against the ESM ones.
+- Subpath types are discoverable under `moduleResolution: "node10"`, which ignores `exports` and is
+  still the default for NestJS projects. A `typesVersions` map now points each subpath at its
+  CommonJS declarations, so `nexus-ai-pro/telephony` and friends type-check without a consumer having
+  to migrate its `tsconfig.json` to `node16`.
+
 ## [1.2.0] - 2026-08-10
 
 ### Added

package/dist/telephony/providers/twilio.js

@@ -158,6 +158,14 @@ export class TwilioTelephonyProvider {
             body.set('StatusCallback', request.statusCallbackUrl);
         if (request.statusCallbackMethod !== undefined)
             body.set('StatusCallbackMethod', request.statusCallbackMethod);
+        if (request.smsUrl !== undefined)
+            body.set('SmsUrl', request.smsUrl);
+        if (request.smsMethod !== undefined)
+            body.set('SmsMethod', request.smsMethod);
+        if (request.smsFallbackUrl !== undefined)
+            body.set('SmsFallbackUrl', request.smsFallbackUrl);
+        if (request.smsFallbackMethod !== undefined)
+            body.set('SmsFallbackMethod', request.smsFallbackMethod);
         if (!body.size) {
             throw new TelephonyProviderError('Twilio phone number update requires at least one field to change', 'twilio');
         }
@@ -296,6 +304,10 @@ export class TwilioTelephonyProvider {
             voiceMethod: normalizeHttpMethod(stringValue(raw.voice_method)),
             statusCallbackUrl: stringValue(raw.status_callback),
             statusCallbackMethod: normalizeHttpMethod(stringValue(raw.status_callback_method)),
+            smsUrl: stringValue(raw.sms_url),
+            smsMethod: normalizeHttpMethod(stringValue(raw.sms_method)),
+            smsFallbackUrl: stringValue(raw.sms_fallback_url),
+            smsFallbackMethod: normalizeHttpMethod(stringValue(raw.sms_fallback_method)),
             capabilities: {
                 voice: capabilities.voice === true,
                 sms: capabilities.sms === true,

package/dist/types/telephony.d.ts

@@ -139,6 +139,11 @@ export interface TelephonyPhoneNumber {
     voiceMethod?: TelephonyHttpMethod;
     statusCallbackUrl?: string;
     statusCallbackMethod?: TelephonyHttpMethod;
+    /** Where the provider currently posts inbound SMS for this number. */
+    smsUrl?: string;
+    smsMethod?: TelephonyHttpMethod;
+    smsFallbackUrl?: string;
+    smsFallbackMethod?: TelephonyHttpMethod;
     capabilities?: {
         voice?: boolean;
         sms?: boolean;
@@ -160,8 +165,20 @@ export interface UpdatePhoneNumberRequest {
     friendlyName?: string;
     voiceUrl?: string;
     voiceMethod?: TelephonyHttpMethod;
+    /**
+     * Where the provider posts call status events.
+     *
+     * This covers the voice leg only. Message delivery receipts are requested per message when
+     * sending, rather than being configured on the number.
+     */
     statusCallbackUrl?: string;
     statusCallbackMethod?: TelephonyHttpMethod;
+    /** Where the provider posts inbound SMS sent to this number. */
+    smsUrl?: string;
+    smsMethod?: TelephonyHttpMethod;
+    /** Used by the provider when {@link smsUrl} errors or times out. */
+    smsFallbackUrl?: string;
+    smsFallbackMethod?: TelephonyHttpMethod;
     signal?: AbortSignal;
 }
 export interface TelephonyWebhookValidationRequest {

package/dist-cjs/agent/loop.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConfig, AgentResult } from '../types/agent.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse } from '../types/response.js';
+export interface AgentModelClient {
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+}
+export declare class AgentLoop {
+    private client;
+    constructor(client: AgentModelClient);
+    run(config: AgentConfig): Promise<AgentResult>;
+    private parseToolArgs;
+}

package/dist-cjs/agent/tool.d.ts

@@ -0,0 +1,16 @@
+import type { ToolDefinition } from '../types/messages.js';
+import type { ToolExecutionResult } from '../types/agent.js';
+export declare function tool<TArgs extends Record<string, unknown> = Record<string, unknown>>(definition: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (args: TArgs) => Promise<unknown> | unknown;
+}): ToolDefinition;
+export declare class ToolExecutor {
+    private tools;
+    constructor(tools?: ToolDefinition[]);
+    register(toolDefinition: ToolDefinition): this;
+    has(name: string): boolean;
+    list(): ToolDefinition[];
+    execute(name: string, args: Record<string, unknown>): Promise<ToolExecutionResult>;
+}

package/dist-cjs/cache/adapters.d.ts

@@ -0,0 +1,42 @@
+export interface CacheAdapter<T = unknown> {
+    get(key: string): Promise<T | undefined> | T | undefined;
+    set(key: string, value: T, ttlSeconds?: number): Promise<void> | void;
+    delete?(key: string): Promise<boolean> | boolean;
+    clear?(): Promise<void> | void;
+}
+export declare class MemoryCacheAdapter<T = unknown> implements CacheAdapter<T> {
+    private entries;
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttlSeconds?: number): void;
+    delete(key: string): boolean;
+    clear(): void;
+}
+export interface RedisLikeClient {
+    get(key: string): Promise<string | null> | string | null;
+    set(key: string, value: string, mode?: string, ttlSeconds?: number): Promise<unknown> | unknown;
+    del?(key: string): Promise<number> | number;
+}
+export declare class RedisCacheAdapter<T = unknown> implements CacheAdapter<T> {
+    private client;
+    private prefix;
+    constructor(client: RedisLikeClient, prefix?: string);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}
+export interface SQLiteLikeDatabase {
+    prepare(sql: string): {
+        get?: (...args: unknown[]) => unknown;
+        run?: (...args: unknown[]) => unknown;
+    };
+    exec?(sql: string): unknown;
+}
+export declare class SQLiteCacheAdapter<T = unknown> implements CacheAdapter<T> {
+    private db;
+    private table;
+    constructor(db: SQLiteLikeDatabase, table?: string);
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttlSeconds?: number): void;
+    delete(key: string): boolean;
+    clear(): void;
+}

package/dist-cjs/cache/memory-cache.d.ts

@@ -0,0 +1,20 @@
+export interface CacheEntry<T> {
+    value: T;
+    expiresAt: number;
+}
+export declare class MemoryCache<T> {
+    private maxEntries;
+    private entries;
+    constructor(maxEntries?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttlSeconds?: number): void;
+    clear(): void;
+    delete(key: string): boolean;
+    clearExpired(): number;
+    stats(): {
+        size: number;
+        maxEntries: number;
+        expiredEntries: number;
+    };
+}
+export declare function createCacheKey(value: unknown): string;

package/dist-cjs/cache/semantic-cache.d.ts

@@ -0,0 +1,19 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse } from '../types/response.js';
+import { type EmbeddingProvider } from '../hallucination/retrieval.js';
+export interface SemanticCacheOptions {
+    enabled?: boolean;
+    similarityThreshold?: number;
+    maxEntries?: number;
+    ttlSeconds?: number;
+    embed?: EmbeddingProvider;
+}
+export declare class SemanticCache {
+    private options;
+    private entries;
+    private embed;
+    constructor(options?: SemanticCacheOptions);
+    get(request: CompletionRequest): Promise<NexusResponse | undefined>;
+    set(key: string, request: CompletionRequest, response: NexusResponse): Promise<void>;
+    clear(): void;
+}

package/dist-cjs/connectors/web.d.ts

@@ -0,0 +1,20 @@
+import type { ToolDefinition } from '../types/messages.js';
+export type WebResolvedAddress = string | {
+    address: string;
+    family?: 4 | 6;
+};
+export interface WebConnectorOptions {
+    allowedDomains?: string[];
+    timeoutMs?: number;
+    userAgent?: string;
+    maxResponseBytes?: number;
+    maxRedirects?: number;
+    /** Explicitly allow loopback/private targets, for example a trusted local development service. */
+    allowPrivateNetworks?: boolean;
+    /** Cloud metadata endpoints remain denied unless this separate high-risk opt-in is enabled. */
+    allowCloudMetadata?: boolean;
+    /** Optional resolver for split-horizon DNS or deterministic tests. Every returned address is validated. */
+    resolveHostname?: (hostname: string) => Promise<readonly WebResolvedAddress[]>;
+}
+export declare function createFetchUrlTool(options?: WebConnectorOptions): ToolDefinition;
+export declare function createSearchTool(search: (query: string) => Promise<unknown>, name?: string): ToolDefinition;

package/dist-cjs/context/index.d.ts

@@ -0,0 +1,2 @@
+export { ContextWindowManager, type ContextWindowRuntime, } from './window.js';
+export type { ContextSummaryConfig, ContextSummaryInput, ContextSummaryMode, ContextSummarizer, ContextWindowConfig, ContextWindowResult, ContextWindowStrategy, ContextWindowUsage, } from '../types/context-window.js';

package/dist-cjs/context/window.d.ts

@@ -0,0 +1,34 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { ContextSummarizer, ContextWindowConfig, ContextWindowResult } from '../types/context-window.js';
+export interface ContextWindowRuntime {
+    summarizer?: ContextSummarizer;
+}
+export declare class ContextWindowManager {
+    private config;
+    private tokenizer;
+    constructor(config?: ContextWindowConfig);
+    optimize(request: CompletionRequest, runtime?: ContextWindowRuntime): Promise<ContextWindowResult<CompletionRequest>>;
+    preview(request: CompletionRequest): ContextWindowResult<CompletionRequest>;
+    private optimizeInternal;
+    private optimizeInternalSync;
+    private resultFromSelection;
+    private selectMessages;
+    private selectByCount;
+    private selectByTokens;
+    private createSummary;
+    private createLocalSummary;
+    private summaryInput;
+    private summaryMessage;
+    private splitMessages;
+    private effectiveStrategy;
+    private strategy;
+    private shouldSummarize;
+    private summaryEnabled;
+    private summaryMode;
+    private summaryConfig;
+    private identity;
+    private serializeMessages;
+    private messageText;
+    private partText;
+}
+export type { ContextSummaryConfig, ContextSummaryInput, ContextSummaryMode, ContextSummarizer, ContextWindowConfig, ContextWindowResult, ContextWindowStrategy, ContextWindowUsage, } from '../types/context-window.js';

package/dist-cjs/core/config-builder.d.ts

@@ -0,0 +1,97 @@
+import { NexusAI } from './nexus.js';
+import type { AnthropicProviderConfig, AuditLogConfig, AzureOpenAIProviderConfig, CacheConfig, CohereProviderConfig, CostBudgetConfig, CustomProviderConfig, DeepSeekProviderConfig, GoogleProviderConfig, GroqProviderConfig, LMStudioProviderConfig, LlamaCppProviderConfig, LoggerConfig, MistralProviderConfig, NexusAIConfig, OllamaProviderConfig, OpenAIProviderConfig, OpenRouterProviderConfig, ProvidersConfig, RateLimitConfig, ResponseFormatConfig, RetryConfig, RoutingConfig, RoutingStrategy } from '../types/config.js';
+import type { ContextWindowConfig } from '../types/context-window.js';
+import type { ImageConfig } from '../types/images.js';
+import type { SecurityConfig, SecurityLevel } from '../types/security.js';
+import type { TokenOptimizerConfig } from '../types/optimizer.js';
+import type { PipelineConfig } from '../pipeline/types.js';
+import type { MetricsConfig } from '../ops/metrics.js';
+import type { HealthConfig } from '../ops/health.js';
+/**
+ * Fluent, typed builder for `NexusAIConfig`.
+ *
+ * The builder is intentionally thin: every method maps directly to a normal config field, so advanced users
+ * can still call `build()` and edit the plain object before passing it to `new NexusAI(...)`.
+ */
+export declare class NexusConfigBuilder {
+    private config;
+    constructor(seed?: Partial<NexusAIConfig>);
+    /** Adds or replaces a provider config by its `ProvidersConfig` key. */
+    provider<Name extends keyof ProvidersConfig>(name: Name, config: NonNullable<ProvidersConfig[Name]>): this;
+    /** Adds OpenAI. */
+    openai(config: OpenAIProviderConfig | string): this;
+    /** Adds Anthropic. */
+    anthropic(config: AnthropicProviderConfig | string): this;
+    /** Adds Google Gemini. */
+    google(config: GoogleProviderConfig | string): this;
+    /** Adds a local Ollama server. */
+    ollama(config?: OllamaProviderConfig): this;
+    /** Adds Groq. */
+    groq(config: GroqProviderConfig | string): this;
+    /** Adds Mistral. */
+    mistral(config: MistralProviderConfig | string): this;
+    /** Adds Cohere. */
+    cohere(config: CohereProviderConfig | string): this;
+    /** Adds OpenRouter. */
+    openrouter(config: OpenRouterProviderConfig | string): this;
+    /** Adds DeepSeek. */
+    deepseek(config: DeepSeekProviderConfig | string): this;
+    /** Adds Azure OpenAI. */
+    azureOpenAI(config: AzureOpenAIProviderConfig): this;
+    /** Adds a local LM Studio OpenAI-compatible server. */
+    lmstudio(config?: LMStudioProviderConfig): this;
+    /** Adds a local llama.cpp OpenAI-compatible server. */
+    llamaCpp(config?: LlamaCppProviderConfig): this;
+    /** Adds a user-defined OpenAI- or Anthropic-compatible endpoint. */
+    custom(config: CustomProviderConfig): this;
+    /** Sets raw routing config. */
+    routing(config: RoutingConfig): this;
+    /** Uses direct routing through a single default model. */
+    direct(model: string): this;
+    /** Uses automatic routing with an optional strategy. */
+    auto(strategy?: RoutingStrategy): this;
+    /** Sets input/output security behavior. */
+    security(config: SecurityLevel | SecurityConfig): this;
+    /** Sets context-window compaction behavior. */
+    contextWindow(config: ContextWindowConfig): this;
+    /** Sets image-provider defaults and registrations. */
+    images(config: ImageConfig): this;
+    /** Sets token optimization behavior. */
+    tokenOptimizer(config: TokenOptimizerConfig): this;
+    /** Sets exact, semantic, or hybrid cache behavior. */
+    cache(config: CacheConfig): this;
+    /** Sets rate limiting behavior. */
+    rateLimit(config: RateLimitConfig): this;
+    /** Sets audit logging behavior. */
+    auditLog(config: AuditLogConfig): this;
+    /** Sets response-format defaults. */
+    responseFormat(config: ResponseFormatConfig): this;
+    /** Sets provider retry behavior. */
+    retry(config: RetryConfig): this;
+    /** Sets request cost-budget behavior. */
+    costBudget(config: CostBudgetConfig): this;
+    /** Sets pipeline hook and trace behavior. */
+    pipeline(config: PipelineConfig): this;
+    /** Sets metrics sink behavior. */
+    metrics(config: MetricsConfig): this;
+    /** Sets provider health scoring behavior. */
+    health(config: HealthConfig): this;
+    /** Sets structured logger behavior. */
+    logger(config: LoggerConfig): this;
+    /** Sets global provider timeout in milliseconds. */
+    timeout(ms: number): this;
+    /** Toggles debug logging. */
+    debug(enabled?: boolean): this;
+    /** Returns a plain `NexusAIConfig` object. */
+    build(): NexusAIConfig;
+    /** Creates a `NexusAI` instance from the current builder state. */
+    create(): NexusAI;
+}
+/**
+ * Starts a fluent `NexusAIConfig` builder.
+ */
+export declare function createNexusConfig(seed?: Partial<NexusAIConfig>): NexusConfigBuilder;
+/**
+ * Identity helper for users who prefer object literals but want type inference and validation in editors.
+ */
+export declare function defineNexusConfig(config: NexusAIConfig): NexusAIConfig;

package/dist-cjs/core/create-nexus.d.ts

@@ -0,0 +1,33 @@
+import { NexusAI } from './nexus.js';
+import type { NexusAIConfig, ProvidersConfig } from '../types/config.js';
+export type CreateNexusProvider = 'openai' | 'anthropic' | 'google' | 'ollama' | 'groq' | 'mistral' | 'cohere' | 'openrouter' | 'deepseek' | 'azureOpenAI' | 'lmstudio' | 'llamaCpp';
+export interface CreateNexusOptions extends Omit<Partial<NexusAIConfig>, 'providers'> {
+    providers?: ProvidersConfig;
+    provider?: CreateNexusProvider;
+    apiKey?: string;
+    baseUrl?: string;
+    endpoint?: string;
+    deployment?: string;
+    apiVersion?: string;
+    model?: string;
+}
+/**
+ * Creates a `NexusAI` instance from either the full production config or a small beginner shorthand.
+ *
+ * Use the full `NexusAIConfig` when you need routing, retries, budgets, hooks, or multiple providers.
+ * Use the shorthand when you only want one provider and one model.
+ *
+ * @example
+ * ```ts
+ * const ai = createNexus({
+ *   provider: 'openai',
+ *   apiKey: process.env.OPENAI_API_KEY!,
+ *   model: 'gpt-5.4-mini',
+ * });
+ * ```
+ */
+export declare function createNexus(config?: NexusAIConfig | CreateNexusOptions): NexusAI;
+/**
+ * Converts the beginner shorthand accepted by `createNexus()` into a normal `NexusAIConfig`.
+ */
+export declare function normalizeCreateNexusConfig(config: NexusAIConfig | CreateNexusOptions): NexusAIConfig;

package/dist-cjs/core/nexus.d.ts

@@ -0,0 +1,222 @@
+import type { NexusAIConfig } from '../types/config.js';
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusPlan } from '../types/planning.js';
+import type { NexusResponse, NexusStream } from '../types/response.js';
+import type { AgentConfig, AgentResult } from '../types/agent.js';
+import type { SpeechRequest, SpeechResponse, TranscriptionRequest, TranscriptionResponse, VoiceProvider, VoiceSessionConfig, VoiceTurnRequest, VoiceTurnResponse } from '../types/voice.js';
+import type { ImageProvider } from '../types/images.js';
+import type { CreateCallRequest, CreateCallResponse, EndCallRequest, GetCallRequest, ListPhoneNumbersRequest, TelephonyCallDetails, TelephonyMediaStreamEvent, TelephonyOutboundAudioMessage, TelephonyPhoneNumber, TelephonyProvider, TelephonyResponseRequest, TelephonyStatusCallback, TelephonyWebhookResponse, TelephonyWebhookValidationRequest, UpdatePhoneNumberRequest } from '../types/telephony.js';
+import type { PipelineStep } from '../pipeline/types.js';
+import type { BaseProvider } from '../providers/base.js';
+import { type VoiceSession } from '../voice/index.js';
+import { ImageManager } from '../images/manager.js';
+import { type VerificationOptions } from '../hallucination/verification.js';
+import { type SelfConsistencyOptions } from '../hallucination/consistency.js';
+import { type BatchOptions, type BatchItemResult } from '../jobs/batch.js';
+import { JobQueue, type QueueOptions } from '../jobs/queue.js';
+import { type EvalCase, type EvalRunResult } from '../evals/runner.js';
+import { type SummarizeVerifyFormatOptions, type WorkflowResult } from '../workflow/chains.js';
+/**
+ * Main runtime facade for provider routing, security, optimization, evals, voice, jobs, and observability.
+ *
+ * Use `new NexusAI(config)` when you want full control, or `createNexus()` for the beginner shorthand.
+ */
+export declare class NexusAI {
+    /** Provider-neutral image generation and editing operations. */
+    readonly images: ImageManager;
+    private config;
+    private providers;
+    private router;
+    private failover;
+    private logger;
+    private security;
+    private contextWindow;
+    private voiceManager;
+    private telephonyManager;
+    private optimizer;
+    private cache;
+    private auditLogger;
+    private rateLimiter;
+    private pipeline;
+    private metrics;
+    private health;
+    private semanticCache;
+    /**
+     * Creates a configured Nexus runtime.
+     *
+     * Provider SDKs are loaded lazily by each provider adapter, so unused providers do not add runtime work.
+     */
+    constructor(config: NexusAIConfig);
+    /**
+     * Runs a completion through the full configured pipeline and returns one normalized response.
+     */
+    complete(request: CompletionRequest): Promise<NexusResponse>;
+    /**
+     * Completes a request and verifies generated claims against provided context.
+     */
+    completeVerified(request: CompletionRequest, options: VerificationOptions): Promise<NexusResponse>;
+    /**
+     * Samples multiple completions and returns the most self-consistent answer.
+     */
+    completeConsistent(request: CompletionRequest, options?: SelfConsistencyOptions): Promise<NexusResponse>;
+    /**
+     * Previews routing, token usage, context fit, cost, and guardrail findings without calling a provider.
+     */
+    plan(request: CompletionRequest): NexusPlan;
+    /**
+     * Streams a completion through the configured pipeline using normalized stream chunks.
+     */
+    stream(request: CompletionRequest): NexusStream;
+    /**
+     * Runs an agent loop with registered tools and iteration limits.
+     */
+    agent(config: AgentConfig): Promise<AgentResult>;
+    /**
+     * Transcribes audio through a registered voice provider.
+     */
+    transcribe(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+    /**
+     * Synthesizes speech through a registered voice provider.
+     */
+    speak(request: SpeechRequest): Promise<SpeechResponse>;
+    /**
+     * Runs one voice turn: optional transcription, completion, and optional speech synthesis.
+     */
+    voice(request: VoiceTurnRequest): Promise<VoiceTurnResponse>;
+    /**
+     * Alias for `voice()` for apps that model calls as turns.
+     */
+    voiceTurn(request: VoiceTurnRequest): Promise<VoiceTurnResponse>;
+    /**
+     * Creates a stateful voice session with transcript history, task prompts, and optional tools.
+     */
+    createVoiceSession(config: VoiceSessionConfig): VoiceSession;
+    /**
+     * Creates an outbound call through a registered telephony provider.
+     */
+    createCall(request: CreateCallRequest): Promise<CreateCallResponse>;
+    /**
+     * Creates a provider-specific webhook response such as TwiML.
+     */
+    createTelephonyResponse(request: TelephonyResponseRequest): Promise<TelephonyWebhookResponse>;
+    /**
+     * Validates a telephony webhook signature when the provider supports it.
+     */
+    validateTelephonyWebhook(request: TelephonyWebhookValidationRequest): Promise<boolean>;
+    parseTelephonyMediaEvent(providerName: string, message: string | Record<string, unknown>): TelephonyMediaStreamEvent | undefined;
+    formatTelephonyAudioMessage(providerName: string, streamId: string, payload: string, options?: {
+        event?: 'media' | 'mark' | 'clear';
+        markName?: string;
+    }): TelephonyOutboundAudioMessage;
+    /**
+     * Reads a call's current provider-side state, including the duration usage metering bills on.
+     */
+    getCall(request: GetCallRequest): Promise<TelephonyCallDetails>;
+    /**
+     * Hangs up a live call through the provider's call-control API.
+     */
+    endCall(request: EndCallRequest): Promise<TelephonyCallDetails>;
+    /**
+     * Parses a provider status webhook into a normalized record. Prefer this over media-stream
+     * lifecycle events when metering usage.
+     */
+    parseTelephonyStatusCallback(providerName: string, body: string | URLSearchParams | Record<string, string | number | boolean | undefined>): TelephonyStatusCallback | undefined;
+    /**
+     * Lists phone numbers owned by the provider account.
+     */
+    listPhoneNumbers(request?: ListPhoneNumbersRequest): Promise<TelephonyPhoneNumber[]>;
+    /**
+     * Points a phone number at a voice webhook and/or status callback.
+     */
+    updatePhoneNumber(request: UpdatePhoneNumberRequest): Promise<TelephonyPhoneNumber>;
+    /**
+     * Registers a custom text provider at runtime.
+     */
+    registerProvider(name: string, provider: BaseProvider): this;
+    /**
+     * Registers a custom voice provider at runtime.
+     */
+    registerVoiceProvider(name: string, provider: VoiceProvider): this;
+    /**
+     * Registers a custom image provider at runtime.
+     */
+    registerImageProvider(name: string, provider: ImageProvider): this;
+    /**
+     * Registers a custom telephony provider at runtime.
+     */
+    registerTelephonyProvider(name: string, provider: TelephonyProvider): this;
+    hasProvider(name: string): boolean;
+    hasVoiceProvider(name: string): boolean;
+    hasImageProvider(name: string): boolean;
+    hasTelephonyProvider(name: string): boolean;
+    /**
+     * Lists configured text providers.
+     */
+    listProviders(): string[];
+    listVoiceProviders(): string[];
+    listImageProviders(): string[];
+    listTelephonyProviders(): string[];
+    /**
+     * Adds a custom pipeline step.
+     */
+    use(step: PipelineStep): this;
+    /**
+     * Runs multiple completion requests with optional concurrency control.
+     */
+    batchComplete(requests: CompletionRequest[], options?: BatchOptions): Promise<Array<BatchItemResult<NexusResponse>>>;
+    /**
+     * Creates an in-process job queue for completion requests.
+     */
+    createQueue(options?: QueueOptions): JobQueue<CompletionRequest, NexusResponse>;
+    /**
+     * Runs eval cases against this Nexus instance.
+     */
+    runEvals(cases: EvalCase<NexusResponse>[]): Promise<EvalRunResult<NexusResponse>>;
+    summarizeVerifyFormat(options: SummarizeVerifyFormatOptions): Promise<WorkflowResult>;
+    /**
+     * Returns current provider health snapshots.
+     */
+    getProviderHealth(): import("../ops/health.js").ProviderHealthSnapshot[];
+    /**
+     * Calls each provider's health check and records the result.
+     */
+    checkProviders(): Promise<Array<{
+        providerName: string;
+        ok: boolean;
+        error?: string;
+    }>>;
+    /**
+     * Returns an in-memory metrics snapshot.
+     */
+    getMetricsSnapshot(): Record<string, unknown>;
+    /**
+     * Returns Prometheus-formatted metrics when metrics are enabled.
+     */
+    getPrometheusMetrics(): string;
+    /**
+     * Clears exact and semantic caches.
+     */
+    clearCache(): void;
+    clearExpiredCache(): number;
+    getCacheStats(): {
+        size: number;
+        maxEntries: number;
+        expiredEntries: number;
+    };
+    private isAuditLogEnabled;
+    private isCacheEnabled;
+    private isCostBudgetEnabled;
+    private isSecurityEnabled;
+    private isTokenOptimizerEnabled;
+    private isContextWindowEnabled;
+    private hasResponseFormat;
+    private streamWithContextWindow;
+    private attachContextWindowToStream;
+    private summarizeContext;
+    private registerConfiguredProviders;
+    private attachTrace;
+    private getCachedResponse;
+    private setCachedResponse;
+    private enforceCostBudget;
+    private estimatedOutputTokens;
+}

package/dist-cjs/core/response-format.d.ts

@@ -0,0 +1,8 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { NexusResponse } from '../types/response.js';
+import type { ResponseFormatConfig } from '../types/config.js';
+export declare class ResponseFormatError extends Error {
+    constructor(message: string);
+}
+export declare function applyResponseFormat(response: NexusResponse, config?: ResponseFormatConfig): NexusResponse;
+export declare function withResponseFormat(request: CompletionRequest, config?: ResponseFormatConfig): CompletionRequest;

package/dist-cjs/core/secure-stream.d.ts

@@ -0,0 +1,3 @@
+import type { SecurityPipeline } from '../security/index.js';
+import type { NexusStream } from '../types/response.js';
+export declare function protectStreamOutput(stream: NexusStream, security: SecurityPipeline, requestSignal?: AbortSignal): NexusStream;

package/dist-cjs/core/streaming.d.ts

@@ -0,0 +1,4 @@
+import type { NexusStream, StreamChunk } from '../types/response.js';
+export declare function collectStream(stream: NexusStream): Promise<string>;
+export declare function mapStream(stream: NexusStream, mapChunk: (chunk: StreamChunk) => StreamChunk | Promise<StreamChunk>): AsyncGenerator<StreamChunk>;
+export declare function createTextStream(text: string): NexusStream;

package/dist-cjs/embeddings/providers.d.ts

@@ -0,0 +1,20 @@
+import type { EmbeddingProvider } from '../hallucination/retrieval.js';
+export interface OpenAIEmbeddingOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}
+export interface GeminiEmbeddingOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}
+export interface CohereEmbeddingOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    inputType?: 'search_document' | 'search_query' | 'classification' | 'clustering';
+}
+export declare function createOpenAIEmbeddingProvider(options: OpenAIEmbeddingOptions): EmbeddingProvider;
+export declare function createGeminiEmbeddingProvider(options: GeminiEmbeddingOptions): EmbeddingProvider;
+export declare function createCohereEmbeddingProvider(options: CohereEmbeddingOptions): EmbeddingProvider;